troyesGEII - Contributions de l’utilisateur [fr]

Cours:ArduinoSansLoopSetup

2026-06-04T13:47:31Z

Bjacquot : /* Gestion du temps */

Il est tout à fait possible de se passer complètement des librairies Arduino, tout en utilisant le logiciel Arduino !
Ou d'utiliser une partie de la librairie Arduino pour simplifier l'usage de certains périphériques.

=liaison série=

On peut utiliser la classe {{Rouge|Serial}} arduino, à condition d'{{Rouge|autoriser les interruptions}} :

<source lang=c>
int main()
{
sei();
Serial.begin(9600);
while(1)
{
Serial.println("top");
_delay_ms(500);
}
}
</source>

=Gestion du temps=

<big>Remplacement</big> :
*utiliser {{Rouge|_delay_ms}} à la place de delay
*utiliser {{Rouge|_delay_us}} à la place de delayMicroseconds

S'il est {{Rouge|indispensable}} d'utiliser les fonctions arduino [https://github.com/arduino/ArduinoCore-avr/blob/master/cores/arduino/wiring.c delay/delayMicroseconds/millis/micros], il faut configurer le Timer1 de la façon suivante :

<source lang=cpp>
void initFonctionsTempsArduino()
{
sei();
// marche pour 328p et 2560 et autres ...
// à adapter suivant le µc
// cf https://github.com/arduino/ArduinoCore-avr/blob/master/cores/arduino/wiring.c
TCCR0A=(1<<WGM01)|(1<<WGM00);
TCCR0B=(1<<CS01)|(1<<CS00);
TIMSK0=(1<<TOIE0);
}

int main()
{
initFonctionsTempsArduino();
Serial.begin(115200);
while(1)
{
delay(100);
Serial.println(millis());
}
}
</source>

***********************************
ATTENTION, dans ce cas il ne
faut surtout pas avoir des
_delay_ms avec de grandes valeurs
***********************************

=i2c=

Il est possible d'utiliser la librairie Arduino Wire, il convient juste d'autoriser les interruptions :

<source lang=cpp>
#include <Wire.h>
int main()
{
sei();
Wire.begin();
while(1)
{
}
}
</source>

=can/adc=

Il est possible d'utiliser la fonction analogRead à condition d'initialiser le convertisseur :

<source lang=cpp>
void initAdcArduino()
{
sei();
// marche pour 328p et 2560 et autres ... pour Fcpu = 16MHz
// à adapter suivant le µc et la fréquence
// cf https://github.com/arduino/ArduinoCore-avr/blob/master/cores/arduino/wiring.c
ADCSRA|=(1<<ADEN)|(1<<ADPS2)|(1<<ADPS1)|(1<<ADPS0);
}

int main()
{
initAdcArduino();
Serial.begin(115200);
while(1)
{
Serial.println(analogRead(A0));
_delay_ms(250);
}
}
</source>

Cours:SaeRobotique

2026-06-01T09:46:13Z

Bjacquot : /* utilisation des leds couleur */

[[Cours:SaeRobotique correction|{{Vert|<big><big>Corrections enseignants</big></big>}}]]

[[Cours:SaeRobotiqueSuiviLigne]]

[[Cours:SaeRobotiqueTennis]]

=Ressources communes=

==structure du programme==

Vous pourrez utiliser la structure de programme suivante :

<source lang=cpp>
enum state {etapeInit,etapeChercheBalle,etapeDeplacementVersBalle};

state etapeSuivante=etapeInit;
state etapeActive=etapeInit;

int main()
{
while(1)
{
// lecture des capteurs en début de boucle
switch (etapeActive)
{
case etapeInit:

// si ... etapeSuivante=
break;
case etapeChercheBalle:

// si ... etapeSuivante=
break;
case etapeDeplacementVersBalle:

// si ... etapeSuivante=
break;
}

// on modifie l'étape active pour la prochaine boucle
etapeActive=etapeSuivante;
}
}
</source>

{{Rouge|<big>*********************************</big>}}
{{Rouge|<big>ne pas déclarer de variables dans</big>}}
{{Rouge|<big> le switch case</big>}}
{{Rouge|<big>*********************************</big>}}

==Programmation : comment faire==

===Exécuter une action une seule fois :===
<source lang=cpp>
while(1)
{
static bool dejaFait=false;
if (dejaFait==false)
{
executerMonAction();
dejaFait=true;
}
}
</source>

===Répéter une action régulièrement===
{| class="wikitable"
|-
|
<source lang=cpp>
void initFonctionsTempsArduino()
{
sei();
// marche pour 328p et 2560 et autres ...
// à adapter suivant le µc
// cf https://github.com/arduino/ArduinoCore-avr/blob/master/cores/arduino/wiring.c
TCCR0A=(1<<WGM01)|(1<<WGM00);
TCCR0B=(1<<CS01)|(1<<CS00);
TIMSK0=(1<<TOIE0);
}

int main()
{
initFonctionsTempsArduino();
while(1)
{
static uint32_t triggerTime=millis();
uint32_t currentTime=millis();
if (currentTime>=triggerTime)
{
faireMonAction();
triggerTime += 500; // prochaine exécution dans 500ms
}
}
}
</source>
||
<source lang=cpp>
void initFonctionsTempsArduino()
{
sei();
// marche pour 328p et 2560 et autres ...
// à adapter suivant le µc
// cf https://github.com/arduino/ArduinoCore-avr/blob/master/cores/arduino/wiring.c
TCCR0A=(1<<WGM01)|(1<<WGM00);
TCCR0B=(1<<CS01)|(1<<CS00);
TIMSK0=(1<<TOIE0);
}

int main()
{
initFonctionsTempsArduino();
while(1)
{
static uint32_t triggerTime=0;
uint32_t currentTime=millis();

switch (etapeActive)
{
case etapeX:
if ( qqch)
{
etapeSuivante=etapeY;
triggerTime=currentTime;
}
break;
case etapeY:
if ( currentTime >= (triggerTime + duree ) )
{
etapeSuivante=etapeZ;
}
break;
case etapeZ:
...
break;
}
etapeActive=etapeSuivante;
}
}
</source>
|}

===Affichage provisoire pour deboggage===

{|
|-
|
<source lang=cpp>
#define debug // mode debug
//ou
#undef debug // mode sans debug

int main()
{
...
while(1)
{
#ifdef debug
Serial.println("juste si debug");
#endif
}
}

</source>
||
<source lang=cpp>
#define DEBUG //If you comment this line, the DEBUG_PRINT & DEBUG_PRINTLN lines are defined as blank.
#ifdef DEBUG //Macros are usually in all capital letters.
#define DEBUG_PRINT(...) Serial.print(__VA_ARGS__) //DEBUG_PRINT is a macro, debug print
#define DEBUG_PRINTLN(...) Serial.println(__VA_ARGS__) //DEBUG_PRINTLN is a macro, debug print with new line
#else
#define DEBUG_PRINT(...) //now defines a blank line
#define DEBUG_PRINTLN(...) //now defines a blank line
#endif
int main()
{
while(1)
{
DEBUG_PRINTLN("juste si debug");
}
}

</source>
|}

===changement d'état d'un capteur===

{|
|-
! au front montant d'un capteur !! 1x si le capteur est actif suffisamment longtemps
|-
| <source lang=cpp>
bool valeurActuelle=valeurInit;
bool valeurPrecedente=valeurInit;

...
int main()
{
...
while(1)
{
valeurPrecedente=valeurActuelle;
valeurActuelle=lireValeurCapteur();
if ( (valeurPrecedente==false) and (valeurActuelle==true) )
{
// action, par ex:
nombreFrontMontant++;
}
}
}
</source>
|| <source lang=cpp>
bool valeurActuelle=valeurInit;
int8_t dureeActif=0;
bool isFront=true;

...
int main()
{
...
while(1)
{
valeurActuelle=lireValeurCapteur();
if (valeurActuelle==true)
{
if (dureeActif>=20)
{
// faire l'action, par ex
if (isFront==true)
{
isFront=false;
nombreFrontMontant++;
}
}
else dureeActif++;
}
else
{
dureeActif=0;
isFront=true;
}
}
}
</source>
|}

===filtrer un capteur tor===

{| class="wikitable"
|-
! filtrer un capteur TOR !! sous forme de fonction pour filtrage de plusieurs capteurs
|-
| <source lang=cpp>

bool rawValue=readCapteur();
static bool value=false;

const uint8_t filterValue=12;
static uint8_t nbTrue=0;
static uint8_t nbFalse=0;

if ( rawValue )
{
if ( nbTrue>= filterValue)
{
value=true;
nbFalse=0;
}
else nbTrue++;
}
else
{
if ( nbFalse>= filterValue)
{
value=false;
nbTrue=0;
}
else nbFalse++;
}
</source>
|| <source lang=cpp>
void filtreTor(bool rawValue,bool & value,uint8_t filterValue,uint8_t & nbTrue,uint8_t & nbFalse)
{
if ( rawValue )
{
if ( nbTrue>= filterValue)
{
value=true;
nbFalse=0;
}
else nbTrue++;
}
else
{
if ( nbFalse>= filterValue)
{
value=false;
nbTrue=0;
}
else nbFalse++;
}
}

int main()
{
...
bool rawValue=rawValueTab[i];
static bool value=false;

const uint8_t filterValue=5;
static uint8_t nbTrue=0;
static uint8_t nbFalse=0;
filtreTor(rawValue,value,filterValue,nbTrue,nbFalse);
...
}
</source>
|}

===Optimiser l'exécution d'une fonction===
<source lang=cpp>
inline void setVitesse(int16_t vmG, int16_t vmD) __attribute__((always_inline));

void setVitesse(int16_t vmG, int16_t vmD)
{
// code de la fonction
...
}

</source>

==utilisation des leds couleur==

Voici comment utiliser une barrette de leds couleur pour afficher la valeur d'un nombre en binaire ( à adapter en fonction du nombre de bits) :

<source lang=cpp>
rgb_color colorTrue{0,5,0};
rgb_color colorFalse{5,0,0};
for(uint16_t i = 0; i < 4; i++)
{
if (bit_is_set(n,i)) colors[i] = colorTrue;
else colors[i] = colorFalse;
}
ledStrip.write(colors, LED_COUNT);
</source>

Une version plus complète permettant de choisir le nombre de bits, ainsi que la position sur le ruban de leds.
<source lang=cpp>
const uint8_t nBits=3;
const uint8_t firstLed=2;
rgb_color colorTrue{0,5,0};
rgb_color colorFalse{5,0,0};
for(uint16_t i = firstLed; i < firstLed+nBits; i++)
{
if (bit_is_set(n,i)) colors[i] = colorTrue;
else colors[i] = colorFalse;
}
ledStrip.write(colors, LED_COUNT);
</source>

==Diagramme d'état==

Pour aller plus loin dans la programmation sous forme de [https://fr.wikipedia.org/wiki/Automate_fini {{Rouge|machine à état fini]}}, vous utiliserez comme base le programme suivant :

[[Media:TestFiniteStateMachine.zip]]

==Composants Kicad==

*Résistances :
**symbole R
**boitier suivant la valeur : 1206(CMS)/Axial DIN0309 (traversant)
*Condensateur
**symbole C
**boitier suivant la valeur 1206(CMS)
*VNH7070
**télécharger et décompresser le fichier [[Media:VNH7070BASTR.zip]]
**ajouter la librairie en suivante la page : https://www.snapeda.com/about/import/#KiCad6
**{{Rouge|attention}} : pour l'ajout de la librairie de l'empreinte, indique comme "pseudo nom" {{Rouge|VNH7070BASTR}}
**modèle 3d
***ajouter le fichier VNH7070BASTR.step
***faire une rotation sur X de 90°
*Arduino Nano
**symbole Arduino_Nano_v2.x
**modèle 3d
***télécharger et décompresser : [[Media:Arduino_nano.STEP.zip]]
***dans les propriétés de la carte (éditeur de pcb), onglet modèle 3d
****ajouter le fichier téléchargé
****rotation X 90
****rotation Z -90
****décalage Z 11mm
***ajouter 2 barrettes M/F
***${KICAD9_3DMODEL_DIR}/Connector_PinSocket_2.54mm.3dshapes/PinSocket_1x15_P2.54mm_Vertical.step
***décaler le 2ème en X de 15,24mm
*bornier à vis : Screw_Terminal_01x02
*MPU-9250
**mettre 2 barrettes sécables 4 contacts, espacées de 6 pas
**[[Media:SparkFun MPU-9250 Breakout.step.zip]]
*convertisseur de niveau
**convertisseur {{Rouge|gt1167}}
***utiliser la librairie : [[Media:GT117.zip]]
***documentation : [[Media:Gt1167.pdf]]
**convertisseur [https://www.sparkfun.com/sparkfun-logic-level-converter-bi-directional.html sparkfun {{Rouge|BOB-12009}}]
***utiliser la librairie : [[Media:BOB-12009.zip]]
***modèle 3d :
****BOB-12009.step
*****rotation 90/0/0
*****translation 0/0/9
****ajouter 2 barrettes M/F : ${KICAD9_3DMODEL_DIR}/Connector_PinSocket_2.54mm.3dshapes/PinSocket_1x06_P2.54mm_Vertical.step
*****rotation 0/0/0
*****translation 5.08/6.35/0 et -5.08/6.35/0
*Autres : [[Media:SaeS2_2025.zip]]
*GroveH : [[Media:groveH.zip]]
*Connecteur à vis : [[Media:1729131.zip]]

Cours:SaeRobotique

2026-06-01T09:36:31Z

Bjacquot : /* Diagramme d'état */

[[Cours:SaeRobotique correction|{{Vert|<big><big>Corrections enseignants</big></big>}}]]

[[Cours:SaeRobotiqueSuiviLigne]]

[[Cours:SaeRobotiqueTennis]]

=Ressources communes=

==structure du programme==

Vous pourrez utiliser la structure de programme suivante :

<source lang=cpp>
enum state {etapeInit,etapeChercheBalle,etapeDeplacementVersBalle};

state etapeSuivante=etapeInit;
state etapeActive=etapeInit;

int main()
{
while(1)
{
// lecture des capteurs en début de boucle
switch (etapeActive)
{
case etapeInit:

// si ... etapeSuivante=
break;
case etapeChercheBalle:

// si ... etapeSuivante=
break;
case etapeDeplacementVersBalle:

// si ... etapeSuivante=
break;
}

// on modifie l'étape active pour la prochaine boucle
etapeActive=etapeSuivante;
}
}
</source>

{{Rouge|<big>*********************************</big>}}
{{Rouge|<big>ne pas déclarer de variables dans</big>}}
{{Rouge|<big> le switch case</big>}}
{{Rouge|<big>*********************************</big>}}

==Programmation : comment faire==

===Exécuter une action une seule fois :===
<source lang=cpp>
while(1)
{
static bool dejaFait=false;
if (dejaFait==false)
{
executerMonAction();
dejaFait=true;
}
}
</source>

===Répéter une action régulièrement===
{| class="wikitable"
|-
|
<source lang=cpp>
void initFonctionsTempsArduino()
{
sei();
// marche pour 328p et 2560 et autres ...
// à adapter suivant le µc
// cf https://github.com/arduino/ArduinoCore-avr/blob/master/cores/arduino/wiring.c
TCCR0A=(1<<WGM01)|(1<<WGM00);
TCCR0B=(1<<CS01)|(1<<CS00);
TIMSK0=(1<<TOIE0);
}

int main()
{
initFonctionsTempsArduino();
while(1)
{
static uint32_t triggerTime=millis();
uint32_t currentTime=millis();
if (currentTime>=triggerTime)
{
faireMonAction();
triggerTime += 500; // prochaine exécution dans 500ms
}
}
}
</source>
||
<source lang=cpp>
void initFonctionsTempsArduino()
{
sei();
// marche pour 328p et 2560 et autres ...
// à adapter suivant le µc
// cf https://github.com/arduino/ArduinoCore-avr/blob/master/cores/arduino/wiring.c
TCCR0A=(1<<WGM01)|(1<<WGM00);
TCCR0B=(1<<CS01)|(1<<CS00);
TIMSK0=(1<<TOIE0);
}

int main()
{
initFonctionsTempsArduino();
while(1)
{
static uint32_t triggerTime=0;
uint32_t currentTime=millis();

switch (etapeActive)
{
case etapeX:
if ( qqch)
{
etapeSuivante=etapeY;
triggerTime=currentTime;
}
break;
case etapeY:
if ( currentTime >= (triggerTime + duree ) )
{
etapeSuivante=etapeZ;
}
break;
case etapeZ:
...
break;
}
etapeActive=etapeSuivante;
}
}
</source>
|}

===Affichage provisoire pour deboggage===

{|
|-
|
<source lang=cpp>
#define debug // mode debug
//ou
#undef debug // mode sans debug

int main()
{
...
while(1)
{
#ifdef debug
Serial.println("juste si debug");
#endif
}
}

</source>
||
<source lang=cpp>
#define DEBUG //If you comment this line, the DEBUG_PRINT & DEBUG_PRINTLN lines are defined as blank.
#ifdef DEBUG //Macros are usually in all capital letters.
#define DEBUG_PRINT(...) Serial.print(__VA_ARGS__) //DEBUG_PRINT is a macro, debug print
#define DEBUG_PRINTLN(...) Serial.println(__VA_ARGS__) //DEBUG_PRINTLN is a macro, debug print with new line
#else
#define DEBUG_PRINT(...) //now defines a blank line
#define DEBUG_PRINTLN(...) //now defines a blank line
#endif
int main()
{
while(1)
{
DEBUG_PRINTLN("juste si debug");
}
}

</source>
|}

===changement d'état d'un capteur===

{|
|-
! au front montant d'un capteur !! 1x si le capteur est actif suffisamment longtemps
|-
| <source lang=cpp>
bool valeurActuelle=valeurInit;
bool valeurPrecedente=valeurInit;

...
int main()
{
...
while(1)
{
valeurPrecedente=valeurActuelle;
valeurActuelle=lireValeurCapteur();
if ( (valeurPrecedente==false) and (valeurActuelle==true) )
{
// action, par ex:
nombreFrontMontant++;
}
}
}
</source>
|| <source lang=cpp>
bool valeurActuelle=valeurInit;
int8_t dureeActif=0;
bool isFront=true;

...
int main()
{
...
while(1)
{
valeurActuelle=lireValeurCapteur();
if (valeurActuelle==true)
{
if (dureeActif>=20)
{
// faire l'action, par ex
if (isFront==true)
{
isFront=false;
nombreFrontMontant++;
}
}
else dureeActif++;
}
else
{
dureeActif=0;
isFront=true;
}
}
}
</source>
|}

===filtrer un capteur tor===

{| class="wikitable"
|-
! filtrer un capteur TOR !! sous forme de fonction pour filtrage de plusieurs capteurs
|-
| <source lang=cpp>

bool rawValue=readCapteur();
static bool value=false;

const uint8_t filterValue=12;
static uint8_t nbTrue=0;
static uint8_t nbFalse=0;

if ( rawValue )
{
if ( nbTrue>= filterValue)
{
value=true;
nbFalse=0;
}
else nbTrue++;
}
else
{
if ( nbFalse>= filterValue)
{
value=false;
nbTrue=0;
}
else nbFalse++;
}
</source>
|| <source lang=cpp>
void filtreTor(bool rawValue,bool & value,uint8_t filterValue,uint8_t & nbTrue,uint8_t & nbFalse)
{
if ( rawValue )
{
if ( nbTrue>= filterValue)
{
value=true;
nbFalse=0;
}
else nbTrue++;
}
else
{
if ( nbFalse>= filterValue)
{
value=false;
nbTrue=0;
}
else nbFalse++;
}
}

int main()
{
...
bool rawValue=rawValueTab[i];
static bool value=false;

const uint8_t filterValue=5;
static uint8_t nbTrue=0;
static uint8_t nbFalse=0;
filtreTor(rawValue,value,filterValue,nbTrue,nbFalse);
...
}
</source>
|}

===Optimiser l'exécution d'une fonction===
<source lang=cpp>
inline void setVitesse(int16_t vmG, int16_t vmD) __attribute__((always_inline));

void setVitesse(int16_t vmG, int16_t vmD)
{
// code de la fonction
...
}

</source>

==utilisation des leds couleur==

Voici comment utiliser une barrette de leds couleur pour afficher la valeur d'un nombre en binaire ( à adapter en fonction du nombre de bits) :

<source lang=cpp>
rgb_color colorTrue{0,5,0};
rgb_color colorFalse{5,0,0};
for(uint16_t i = 0; i < 4; i++)
{
if (bit_is_set(n,i)) colors[i] = colorTrue;
else colors[i] = colorFalse;
}
ledStrip.write(colors, LED_COUNT);
</source>

==Diagramme d'état==

Pour aller plus loin dans la programmation sous forme de [https://fr.wikipedia.org/wiki/Automate_fini {{Rouge|machine à état fini]}}, vous utiliserez comme base le programme suivant :

[[Media:TestFiniteStateMachine.zip]]

==Composants Kicad==

*Résistances :
**symbole R
**boitier suivant la valeur : 1206(CMS)/Axial DIN0309 (traversant)
*Condensateur
**symbole C
**boitier suivant la valeur 1206(CMS)
*VNH7070
**télécharger et décompresser le fichier [[Media:VNH7070BASTR.zip]]
**ajouter la librairie en suivante la page : https://www.snapeda.com/about/import/#KiCad6
**{{Rouge|attention}} : pour l'ajout de la librairie de l'empreinte, indique comme "pseudo nom" {{Rouge|VNH7070BASTR}}
**modèle 3d
***ajouter le fichier VNH7070BASTR.step
***faire une rotation sur X de 90°
*Arduino Nano
**symbole Arduino_Nano_v2.x
**modèle 3d
***télécharger et décompresser : [[Media:Arduino_nano.STEP.zip]]
***dans les propriétés de la carte (éditeur de pcb), onglet modèle 3d
****ajouter le fichier téléchargé
****rotation X 90
****rotation Z -90
****décalage Z 11mm
***ajouter 2 barrettes M/F
***${KICAD9_3DMODEL_DIR}/Connector_PinSocket_2.54mm.3dshapes/PinSocket_1x15_P2.54mm_Vertical.step
***décaler le 2ème en X de 15,24mm
*bornier à vis : Screw_Terminal_01x02
*MPU-9250
**mettre 2 barrettes sécables 4 contacts, espacées de 6 pas
**[[Media:SparkFun MPU-9250 Breakout.step.zip]]
*convertisseur de niveau
**convertisseur {{Rouge|gt1167}}
***utiliser la librairie : [[Media:GT117.zip]]
***documentation : [[Media:Gt1167.pdf]]
**convertisseur [https://www.sparkfun.com/sparkfun-logic-level-converter-bi-directional.html sparkfun {{Rouge|BOB-12009}}]
***utiliser la librairie : [[Media:BOB-12009.zip]]
***modèle 3d :
****BOB-12009.step
*****rotation 90/0/0
*****translation 0/0/9
****ajouter 2 barrettes M/F : ${KICAD9_3DMODEL_DIR}/Connector_PinSocket_2.54mm.3dshapes/PinSocket_1x06_P2.54mm_Vertical.step
*****rotation 0/0/0
*****translation 5.08/6.35/0 et -5.08/6.35/0
*Autres : [[Media:SaeS2_2025.zip]]
*GroveH : [[Media:groveH.zip]]
*Connecteur à vis : [[Media:1729131.zip]]

Cours:SaeRobotique

2026-06-01T08:48:24Z

Bjacquot : /* structure du programme */

[[Cours:SaeRobotique correction|{{Vert|<big><big>Corrections enseignants</big></big>}}]]

[[Cours:SaeRobotiqueSuiviLigne]]

[[Cours:SaeRobotiqueTennis]]

=Ressources communes=

==structure du programme==

Vous pourrez utiliser la structure de programme suivante :

<source lang=cpp>
enum state {etapeInit,etapeChercheBalle,etapeDeplacementVersBalle};

state etapeSuivante=etapeInit;
state etapeActive=etapeInit;

int main()
{
while(1)
{
// lecture des capteurs en début de boucle
switch (etapeActive)
{
case etapeInit:

// si ... etapeSuivante=
break;
case etapeChercheBalle:

// si ... etapeSuivante=
break;
case etapeDeplacementVersBalle:

// si ... etapeSuivante=
break;
}

// on modifie l'étape active pour la prochaine boucle
etapeActive=etapeSuivante;
}
}
</source>

{{Rouge|<big>*********************************</big>}}
{{Rouge|<big>ne pas déclarer de variables dans</big>}}
{{Rouge|<big> le switch case</big>}}
{{Rouge|<big>*********************************</big>}}

==Programmation : comment faire==

===Exécuter une action une seule fois :===
<source lang=cpp>
while(1)
{
static bool dejaFait=false;
if (dejaFait==false)
{
executerMonAction();
dejaFait=true;
}
}
</source>

===Répéter une action régulièrement===
{| class="wikitable"
|-
|
<source lang=cpp>
void initFonctionsTempsArduino()
{
sei();
// marche pour 328p et 2560 et autres ...
// à adapter suivant le µc
// cf https://github.com/arduino/ArduinoCore-avr/blob/master/cores/arduino/wiring.c
TCCR0A=(1<<WGM01)|(1<<WGM00);
TCCR0B=(1<<CS01)|(1<<CS00);
TIMSK0=(1<<TOIE0);
}

int main()
{
initFonctionsTempsArduino();
while(1)
{
static uint32_t triggerTime=millis();
uint32_t currentTime=millis();
if (currentTime>=triggerTime)
{
faireMonAction();
triggerTime += 500; // prochaine exécution dans 500ms
}
}
}
</source>
||
<source lang=cpp>
void initFonctionsTempsArduino()
{
sei();
// marche pour 328p et 2560 et autres ...
// à adapter suivant le µc
// cf https://github.com/arduino/ArduinoCore-avr/blob/master/cores/arduino/wiring.c
TCCR0A=(1<<WGM01)|(1<<WGM00);
TCCR0B=(1<<CS01)|(1<<CS00);
TIMSK0=(1<<TOIE0);
}

int main()
{
initFonctionsTempsArduino();
while(1)
{
static uint32_t triggerTime=0;
uint32_t currentTime=millis();

switch (etapeActive)
{
case etapeX:
if ( qqch)
{
etapeSuivante=etapeY;
triggerTime=currentTime;
}
break;
case etapeY:
if ( currentTime >= (triggerTime + duree ) )
{
etapeSuivante=etapeZ;
}
break;
case etapeZ:
...
break;
}
etapeActive=etapeSuivante;
}
}
</source>
|}

===Affichage provisoire pour deboggage===

{|
|-
|
<source lang=cpp>
#define debug // mode debug
//ou
#undef debug // mode sans debug

int main()
{
...
while(1)
{
#ifdef debug
Serial.println("juste si debug");
#endif
}
}

</source>
||
<source lang=cpp>
#define DEBUG //If you comment this line, the DEBUG_PRINT & DEBUG_PRINTLN lines are defined as blank.
#ifdef DEBUG //Macros are usually in all capital letters.
#define DEBUG_PRINT(...) Serial.print(__VA_ARGS__) //DEBUG_PRINT is a macro, debug print
#define DEBUG_PRINTLN(...) Serial.println(__VA_ARGS__) //DEBUG_PRINTLN is a macro, debug print with new line
#else
#define DEBUG_PRINT(...) //now defines a blank line
#define DEBUG_PRINTLN(...) //now defines a blank line
#endif
int main()
{
while(1)
{
DEBUG_PRINTLN("juste si debug");
}
}

</source>
|}

===changement d'état d'un capteur===

{|
|-
! au front montant d'un capteur !! 1x si le capteur est actif suffisamment longtemps
|-
| <source lang=cpp>
bool valeurActuelle=valeurInit;
bool valeurPrecedente=valeurInit;

...
int main()
{
...
while(1)
{
valeurPrecedente=valeurActuelle;
valeurActuelle=lireValeurCapteur();
if ( (valeurPrecedente==false) and (valeurActuelle==true) )
{
// action, par ex:
nombreFrontMontant++;
}
}
}
</source>
|| <source lang=cpp>
bool valeurActuelle=valeurInit;
int8_t dureeActif=0;
bool isFront=true;

...
int main()
{
...
while(1)
{
valeurActuelle=lireValeurCapteur();
if (valeurActuelle==true)
{
if (dureeActif>=20)
{
// faire l'action, par ex
if (isFront==true)
{
isFront=false;
nombreFrontMontant++;
}
}
else dureeActif++;
}
else
{
dureeActif=0;
isFront=true;
}
}
}
</source>
|}

===filtrer un capteur tor===

{| class="wikitable"
|-
! filtrer un capteur TOR !! sous forme de fonction pour filtrage de plusieurs capteurs
|-
| <source lang=cpp>

bool rawValue=readCapteur();
static bool value=false;

const uint8_t filterValue=12;
static uint8_t nbTrue=0;
static uint8_t nbFalse=0;

if ( rawValue )
{
if ( nbTrue>= filterValue)
{
value=true;
nbFalse=0;
}
else nbTrue++;
}
else
{
if ( nbFalse>= filterValue)
{
value=false;
nbTrue=0;
}
else nbFalse++;
}
</source>
|| <source lang=cpp>
void filtreTor(bool rawValue,bool & value,uint8_t filterValue,uint8_t & nbTrue,uint8_t & nbFalse)
{
if ( rawValue )
{
if ( nbTrue>= filterValue)
{
value=true;
nbFalse=0;
}
else nbTrue++;
}
else
{
if ( nbFalse>= filterValue)
{
value=false;
nbTrue=0;
}
else nbFalse++;
}
}

int main()
{
...
bool rawValue=rawValueTab[i];
static bool value=false;

const uint8_t filterValue=5;
static uint8_t nbTrue=0;
static uint8_t nbFalse=0;
filtreTor(rawValue,value,filterValue,nbTrue,nbFalse);
...
}
</source>
|}

===Optimiser l'exécution d'une fonction===
<source lang=cpp>
inline void setVitesse(int16_t vmG, int16_t vmD) __attribute__((always_inline));

void setVitesse(int16_t vmG, int16_t vmD)
{
// code de la fonction
...
}

</source>

==Diagramme d'état==

Pour aller plus loin dans la programmation sous forme de [https://fr.wikipedia.org/wiki/Automate_fini {{Rouge|machine à état fini]}}, vous utiliserez comme base le programme suivant :

[[Media:TestFiniteStateMachine.zip]]

==Composants Kicad==

*Résistances :
**symbole R
**boitier suivant la valeur : 1206(CMS)/Axial DIN0309 (traversant)
*Condensateur
**symbole C
**boitier suivant la valeur 1206(CMS)
*VNH7070
**télécharger et décompresser le fichier [[Media:VNH7070BASTR.zip]]
**ajouter la librairie en suivante la page : https://www.snapeda.com/about/import/#KiCad6
**{{Rouge|attention}} : pour l'ajout de la librairie de l'empreinte, indique comme "pseudo nom" {{Rouge|VNH7070BASTR}}
**modèle 3d
***ajouter le fichier VNH7070BASTR.step
***faire une rotation sur X de 90°
*Arduino Nano
**symbole Arduino_Nano_v2.x
**modèle 3d
***télécharger et décompresser : [[Media:Arduino_nano.STEP.zip]]
***dans les propriétés de la carte (éditeur de pcb), onglet modèle 3d
****ajouter le fichier téléchargé
****rotation X 90
****rotation Z -90
****décalage Z 11mm
***ajouter 2 barrettes M/F
***${KICAD9_3DMODEL_DIR}/Connector_PinSocket_2.54mm.3dshapes/PinSocket_1x15_P2.54mm_Vertical.step
***décaler le 2ème en X de 15,24mm
*bornier à vis : Screw_Terminal_01x02
*MPU-9250
**mettre 2 barrettes sécables 4 contacts, espacées de 6 pas
**[[Media:SparkFun MPU-9250 Breakout.step.zip]]
*convertisseur de niveau
**convertisseur {{Rouge|gt1167}}
***utiliser la librairie : [[Media:GT117.zip]]
***documentation : [[Media:Gt1167.pdf]]
**convertisseur [https://www.sparkfun.com/sparkfun-logic-level-converter-bi-directional.html sparkfun {{Rouge|BOB-12009}}]
***utiliser la librairie : [[Media:BOB-12009.zip]]
***modèle 3d :
****BOB-12009.step
*****rotation 90/0/0
*****translation 0/0/9
****ajouter 2 barrettes M/F : ${KICAD9_3DMODEL_DIR}/Connector_PinSocket_2.54mm.3dshapes/PinSocket_1x06_P2.54mm_Vertical.step
*****rotation 0/0/0
*****translation 5.08/6.35/0 et -5.08/6.35/0
*Autres : [[Media:SaeS2_2025.zip]]
*GroveH : [[Media:groveH.zip]]
*Connecteur à vis : [[Media:1729131.zip]]

Cours:SaeRobotique

2026-06-01T08:48:04Z

Bjacquot : /* structure du programme */

[[Cours:SaeRobotique correction|{{Vert|<big><big>Corrections enseignants</big></big>}}]]

[[Cours:SaeRobotiqueSuiviLigne]]

[[Cours:SaeRobotiqueTennis]]

=Ressources communes=

==structure du programme==

Vous pourrez utiliser la structure de programme suivante :

<source lang=cpp>
enum state {etapeInit,etapeChercheBalle,etapeDeplacementVersBalle};

state etapeSuivante=etapeInit;
state etapeActive=etapeInit;

int main()
{
while(1)
{
// lecture des capteurs en début de boucle
switch (etapeActive)
{
case etapeInit:

// si ... etapeSuivante=
break;
case etapeChercheBalle:

// si ... etapeSuivante=
break;
case etapeDeplacementVersBalle:

// si ... etapeSuivante=
break;
}

// on modifie l'étape active pour la prochaine boucle
etapeActive=etapeSuivante;
}
}
</source>

{{Rouge|<big>*********************************</big>}}
{{Rouge|<big>ne pas déclarer de variables dans</big>}}
{{Rouge|<big> le switch case</big>}}
{{Rouge|<big>*********************************</big>}}

==Programmation : comment faire==

===Exécuter une action une seule fois :===
<source lang=cpp>
while(1)
{
static bool dejaFait=false;
if (dejaFait==false)
{
executerMonAction();
dejaFait=true;
}
}
</source>

===Répéter une action régulièrement===
{| class="wikitable"
|-
|
<source lang=cpp>
void initFonctionsTempsArduino()
{
sei();
// marche pour 328p et 2560 et autres ...
// à adapter suivant le µc
// cf https://github.com/arduino/ArduinoCore-avr/blob/master/cores/arduino/wiring.c
TCCR0A=(1<<WGM01)|(1<<WGM00);
TCCR0B=(1<<CS01)|(1<<CS00);
TIMSK0=(1<<TOIE0);
}

int main()
{
initFonctionsTempsArduino();
while(1)
{
static uint32_t triggerTime=millis();
uint32_t currentTime=millis();
if (currentTime>=triggerTime)
{
faireMonAction();
triggerTime += 500; // prochaine exécution dans 500ms
}
}
}
</source>
||
<source lang=cpp>
void initFonctionsTempsArduino()
{
sei();
// marche pour 328p et 2560 et autres ...
// à adapter suivant le µc
// cf https://github.com/arduino/ArduinoCore-avr/blob/master/cores/arduino/wiring.c
TCCR0A=(1<<WGM01)|(1<<WGM00);
TCCR0B=(1<<CS01)|(1<<CS00);
TIMSK0=(1<<TOIE0);
}

int main()
{
initFonctionsTempsArduino();
while(1)
{
static uint32_t triggerTime=0;
uint32_t currentTime=millis();

switch (etapeActive)
{
case etapeX:
if ( qqch)
{
etapeSuivante=etapeY;
triggerTime=currentTime;
}
break;
case etapeY:
if ( currentTime >= (triggerTime + duree ) )
{
etapeSuivante=etapeZ;
}
break;
case etapeZ:
...
break;
}
etapeActive=etapeSuivante;
}
}
</source>
|}

===Affichage provisoire pour deboggage===

{|
|-
|
<source lang=cpp>
#define debug // mode debug
//ou
#undef debug // mode sans debug

int main()
{
...
while(1)
{
#ifdef debug
Serial.println("juste si debug");
#endif
}
}

</source>
||
<source lang=cpp>
#define DEBUG //If you comment this line, the DEBUG_PRINT & DEBUG_PRINTLN lines are defined as blank.
#ifdef DEBUG //Macros are usually in all capital letters.
#define DEBUG_PRINT(...) Serial.print(__VA_ARGS__) //DEBUG_PRINT is a macro, debug print
#define DEBUG_PRINTLN(...) Serial.println(__VA_ARGS__) //DEBUG_PRINTLN is a macro, debug print with new line
#else
#define DEBUG_PRINT(...) //now defines a blank line
#define DEBUG_PRINTLN(...) //now defines a blank line
#endif
int main()
{
while(1)
{
DEBUG_PRINTLN("juste si debug");
}
}

</source>
|}

===changement d'état d'un capteur===

{|
|-
! au front montant d'un capteur !! 1x si le capteur est actif suffisamment longtemps
|-
| <source lang=cpp>
bool valeurActuelle=valeurInit;
bool valeurPrecedente=valeurInit;

...
int main()
{
...
while(1)
{
valeurPrecedente=valeurActuelle;
valeurActuelle=lireValeurCapteur();
if ( (valeurPrecedente==false) and (valeurActuelle==true) )
{
// action, par ex:
nombreFrontMontant++;
}
}
}
</source>
|| <source lang=cpp>
bool valeurActuelle=valeurInit;
int8_t dureeActif=0;
bool isFront=true;

...
int main()
{
...
while(1)
{
valeurActuelle=lireValeurCapteur();
if (valeurActuelle==true)
{
if (dureeActif>=20)
{
// faire l'action, par ex
if (isFront==true)
{
isFront=false;
nombreFrontMontant++;
}
}
else dureeActif++;
}
else
{
dureeActif=0;
isFront=true;
}
}
}
</source>
|}

===filtrer un capteur tor===

{| class="wikitable"
|-
! filtrer un capteur TOR !! sous forme de fonction pour filtrage de plusieurs capteurs
|-
| <source lang=cpp>

bool rawValue=readCapteur();
static bool value=false;

const uint8_t filterValue=12;
static uint8_t nbTrue=0;
static uint8_t nbFalse=0;

if ( rawValue )
{
if ( nbTrue>= filterValue)
{
value=true;
nbFalse=0;
}
else nbTrue++;
}
else
{
if ( nbFalse>= filterValue)
{
value=false;
nbTrue=0;
}
else nbFalse++;
}
</source>
|| <source lang=cpp>
void filtreTor(bool rawValue,bool & value,uint8_t filterValue,uint8_t & nbTrue,uint8_t & nbFalse)
{
if ( rawValue )
{
if ( nbTrue>= filterValue)
{
value=true;
nbFalse=0;
}
else nbTrue++;
}
else
{
if ( nbFalse>= filterValue)
{
value=false;
nbTrue=0;
}
else nbFalse++;
}
}

int main()
{
...
bool rawValue=rawValueTab[i];
static bool value=false;

const uint8_t filterValue=5;
static uint8_t nbTrue=0;
static uint8_t nbFalse=0;
filtreTor(rawValue,value,filterValue,nbTrue,nbFalse);
...
}
</source>
|}

===Optimiser l'exécution d'une fonction===
<source lang=cpp>
inline void setVitesse(int16_t vmG, int16_t vmD) __attribute__((always_inline));

void setVitesse(int16_t vmG, int16_t vmD)
{
// code de la fonction
...
}

</source>

==Diagramme d'état==

Pour aller plus loin dans la programmation sous forme de [https://fr.wikipedia.org/wiki/Automate_fini {{Rouge|machine à état fini]}}, vous utiliserez comme base le programme suivant :

[[Media:TestFiniteStateMachine.zip]]

==Composants Kicad==

*Résistances :
**symbole R
**boitier suivant la valeur : 1206(CMS)/Axial DIN0309 (traversant)
*Condensateur
**symbole C
**boitier suivant la valeur 1206(CMS)
*VNH7070
**télécharger et décompresser le fichier [[Media:VNH7070BASTR.zip]]
**ajouter la librairie en suivante la page : https://www.snapeda.com/about/import/#KiCad6
**{{Rouge|attention}} : pour l'ajout de la librairie de l'empreinte, indique comme "pseudo nom" {{Rouge|VNH7070BASTR}}
**modèle 3d
***ajouter le fichier VNH7070BASTR.step
***faire une rotation sur X de 90°
*Arduino Nano
**symbole Arduino_Nano_v2.x
**modèle 3d
***télécharger et décompresser : [[Media:Arduino_nano.STEP.zip]]
***dans les propriétés de la carte (éditeur de pcb), onglet modèle 3d
****ajouter le fichier téléchargé
****rotation X 90
****rotation Z -90
****décalage Z 11mm
***ajouter 2 barrettes M/F
***${KICAD9_3DMODEL_DIR}/Connector_PinSocket_2.54mm.3dshapes/PinSocket_1x15_P2.54mm_Vertical.step
***décaler le 2ème en X de 15,24mm
*bornier à vis : Screw_Terminal_01x02
*MPU-9250
**mettre 2 barrettes sécables 4 contacts, espacées de 6 pas
**[[Media:SparkFun MPU-9250 Breakout.step.zip]]
*convertisseur de niveau
**convertisseur {{Rouge|gt1167}}
***utiliser la librairie : [[Media:GT117.zip]]
***documentation : [[Media:Gt1167.pdf]]
**convertisseur [https://www.sparkfun.com/sparkfun-logic-level-converter-bi-directional.html sparkfun {{Rouge|BOB-12009}}]
***utiliser la librairie : [[Media:BOB-12009.zip]]
***modèle 3d :
****BOB-12009.step
*****rotation 90/0/0
*****translation 0/0/9
****ajouter 2 barrettes M/F : ${KICAD9_3DMODEL_DIR}/Connector_PinSocket_2.54mm.3dshapes/PinSocket_1x06_P2.54mm_Vertical.step
*****rotation 0/0/0
*****translation 5.08/6.35/0 et -5.08/6.35/0
*Autres : [[Media:SaeS2_2025.zip]]
*GroveH : [[Media:groveH.zip]]
*Connecteur à vis : [[Media:1729131.zip]]

Fichier:CircuitBUT2.png

2026-05-28T06:47:45Z

Bjacquot : Bjacquot a téléversé une nouvelle version de Fichier:CircuitBUT2.png

Cours:SaeRobotiqueSuiviLigne

2026-05-27T07:55:18Z

Bjacquot : /* MPU9250 */

=Utiliser des librairies arduino avec un main =

[[Cours:ArduinoSansLoopSetup|Arduino sans loop/setup]]

Un certain nombre de librairies utilisent les fontions arduino [https://github.com/arduino/ArduinoCore-avr/blob/master/cores/arduino/wiring.c delay/delayMicroseconds/millis/micros]

Ces fonctions utilisent le Timer0 et en particulier l'interruption de débordement.

Ce Timer est configuré dans la fonction [https://github.com/arduino/ArduinoCore-avr/blob/master/cores/arduino/wiring.c init()], qui est appelée dans le [https://github.com/arduino/ArduinoCore-avr/blob/master/cores/arduino/main.cpp "main arduino"]

{|
|-
|
On peut donc initialiser ce Timer0 pour qu'il génère un débordement tel qu'attendu.

Ainsi les fonctions de gestion du temps Arduino peuvent fonctionner comme prévu et on peut ainsi utiliser les librairies qui en dépendent :

<source lang=cpp>
void initFonctionsTempsArduino()
{
sei();
// marche pour 328p et 2560 et autres ...
// à adapter suivant le µc
// cf https://github.com/arduino/ArduinoCore-avr/blob/master/cores/arduino/wiring.c
TCCR0A=(1<<WGM01)|(1<<WGM00);
TCCR0B=(1<<CS01)|(1<<CS00);
TIMSK0=(1<<TOIE0);
}

int main()
{
initFonctionsTempsArduino();
Serial.begin(115200);
while(1)
{
delay(100);
Serial.println(millis());
}
}
</source>

||
<source lang=cpp>
/*
Exemple pour le capteur vl53l1x :
cf exemple de la librairie pour des commentaires
*/
#include <Wire.h>
#include <VL53L1X.h>
VL53L1X sensor;

void initFonctionsTempsArduino()
{
sei();
// marche pour 328p et 2560 et autres ...
// à adapter suivant le µc
// cf https://github.com/arduino/ArduinoCore-avr/blob/master/cores/arduino/wiring.c
TCCR0A=(1<<WGM01)|(1<<WGM00);
TCCR0B=(1<<CS01)|(1<<CS00);
TIMSK0=(1<<TOIE0);
}

int main()
{
initFonctionsTempsArduino();
while (!Serial) {}
Serial.begin(115200);
Wire.begin();
Wire.setClock(400000); // use 400 kHz I2C
sensor.setTimeout(500);
if (!sensor.init())
{
Serial.println("Failed to detect and initialize sensor!");
while (1);
}
sensor.setDistanceMode(VL53L1X::Long);
sensor.setMeasurementTimingBudget(50000);
sensor.startContinuous(50);
while(1)
{
Serial.print(sensor.read());
if (sensor.timeoutOccurred()) { Serial.print(" TIMEOUT"); }
Serial.println();
}
}
</source>
|}

=Augmenter la rapidité des Lidars=
<source lang=cpp>
sensors[i].setMeasurementTimingBudget(20000);
sensors[i].setDistanceMode(VL53L1X::Short);
sensors[i].startContinuous(20);
sensors[0].read(false);
</source>

= Séquence 1 : tâches élémentaires individuelles =

* Tâches de suivi de ligne (un étudiant sur chaque tâche) :
** suivi de cap avec MPU9250
** suivi avec capteurs photorélectifs (nombre de capteurs à choisir)
** suivi avec Lidar, en suivant un mur sur le côté

* s'arrêter à la fin du parcours

* À faire globalement : câblage robot, sécurité

==Livrable 1==
* faire des recherches pour rendre un dossier par groupe (pour lundi 27/05) expliquant : le pont en H, schéma sécurité et chaque partie (a, b, c)
* évaluation le 24/05 (code + questions + fonctionnement)

= Séquence 2 : tâches complexes individuelles + réalisation shield =

* Tâches de suivi (à modifier)
** Capteurs photoréflectifs : détection de marques à droite (si marque : on tourne à droite à l'intersection, sinon tout droit). Détection des marques à gauche : stop et recul pendant 1 seconde (environ) et on repart (pas d'arrêt sur le second passage)
** Lidar : suivi de mur à gauche ET à droite (priorité en suivi à droite). Faire tomber une première barre, pas la seconde.

* Trois cartes à réaliser (une par étudiant)
** carte avec capteurs photoreflectifs
** carte drivers moteur
** carte shield arduino nano

==Livrable 2==

* évaluation le 02/06 (routage/fabrication)

= Séquence 3 : Fusion des trois tâches et programmation globale=

==Livrable 3 ==

= Rapport final =

* Rapport final :
** '''À envoyer au format pdf par mail avant le DD/MM/YY à HH'''
** Diagramme de Gantt
** diagramme algorithme général
** stratégie de résolution de chaque tâche
** Mini-concours à la fin pour sélectionner le meilleur robot (évaluation des capacités du robot, par étudiant en fonction de l'organisation prévue).
** Chiffrage incluant le matériel ainsi que les ressources humaines.

=Organisation=

*Fonctionnement en trinôme sur 12 jours
**9h-12h
**13h30-16h30
*{{Rouge|Compte rendu écrit quotidien individuel}}
**sera contrôlé chaque matin
**doit indiquer les tâches réalisées la veille
**doit indiquer le travail à réaliser le jour même

=Ressources=

==MPU9250==

on va uniquement utiliser le magnétomètre de l'IMU MPU9250.

Le principe est le suivant :

<source lang=cpp>
#include "MPU9250.h"

MPU9250 mpu;

void initFonctionsTempsArduino()
{
sei();
// marche pour 328p et 2560 et autres ...
// à adapter suivant le µc
// cf https://github.com/arduino/ArduinoCore-avr/blob/master/cores/arduino/wiring.c
TCCR0A=(1<<WGM01)|(1<<WGM00);
TCCR0B=(1<<CS01)|(1<<CS00);
TIMSK0=(1<<TOIE0);
}

int main()
{
sei();
initFonctionsTempsArduino();
Serial.begin(115200);
Wire.begin();

if (!mpu.setup(0x68)) {
while (1) {
Serial.println("MPU connection failed. Please check your connection with `connection_check` example.");
delay(5000);
}
}
// il faudra calibrer le magnétomètre
// les valeurs sont propres à chaque composant
// mpu.setMagBias(-56.47, 59.92, 0);
// mpu.setMagScale(0.98, 1.10, 1);

while(1)
{
// attention, lecture toutes les 15ms max !!!
if (mpu.available())
{
mpu.update_mag();
print_mag();
}
}
}

void print_mag() {
Serial.print("angle, Hx, Hy : ");
float angle=0;
Serial.print(angle,2);
Serial.print(" , ");
Serial.print(mpu.getMagX(), 2);
Serial.print(" , ");
Serial.println(mpu.getMagY(), 2);
}
</source>

==Composants/cartes==
*[[Cours:capteurPhotoReflectif|capteur '''photoréflectif''' pour détection de la {{Rouge|ligne}}]]
*convertisseur de niveau:
**https://www.eeweb.com/level-shifting-techniques-in-i2c-bus-design/
*Batterie LiFePo4
**assemblage de 4 éléments LiFePo4
**documentation sur les cellules [[Media:CellulesLiFePo4.pdf]]
**tensions à ne pas dépasser :
***maximum : 3,45V/élément
***minimum : 2,65V/élément
***ne pas démarrer le robot : 2,85V/élément
*divers
**Commutateur d'arrêt d'urgence https://fr.farnell.com/idec/yw1b-v4e01r/commut-bp-e-stop-spst-nc-10a-120v/dp/2833849?ost=2833849
**Régulateur ajustable 1,25 à 30 Vcc https://www.gotronic.fr/art-regulateur-ajustable-1-25-a-30-vcc-gt134-26094.htm
*driver de moteur
**https://www.cytron.io/p-13amp-6v-30v-dc-motor-driver
*capteurs de distance/contact
**HC-SR04 cf fiche technique sur la page : https://www.gotronic.fr/art-module-de-detection-us-hc-sr04-20912.htm
**VL53L1X
***https://www.robotshop.com/eu/fr/platine-deploiement-capteur-distance-tof-regulateur-tension-vl53l1x.html
***https://github.com/pololu/vl53l1x-arduino
**Mini Microrupteur - SPDT https://www.robotshop.com/eu/fr/mini-microrupteur-spdt-levier-rouleau.html
**GP2Yxxxx https://www.gotronic.fr/art-capteur-de-mesure-sharp-gp2y0a41sk0f-18338.htm
**lidar tfmini-s
***https://www.robotshop.com/eu/fr/module-micro-lidar-tfmini-s-benewake-i2c-12m.html
***https://www.arduino.cc/reference/en/libraries/tfmpi2c/
**lidar Lite 3
***https://www.robotshop.com/eu/fr/capteur-distance-laser-haute-performance-lidar-lite-3-llv3hp.html
***https://github.com/RobotShop/LIDARLite_v3_Arduino_Library
*caméra
**pixyv2
***https://pixycam.com/pixy2/
***[[Cours:TPS_2103_tp_pixy|TP caméra pixy]]
***Avoir un PixyMon plus rapide dans la g.008 :
****utiliser un 2ème poste
****ne pas se connecter sur nomachine
****lancer un terminal
****lancer la commande PixyMon
*IMU
**Explications du principe du capteur mpu9250 : https://learn.sparkfun.com/tutorials/mpu-9250-hookup-guide/all
**Bibliothèque à utiliser : dans le gestionnaire de bibliothèque => ''by hideakitai'' (v 0.4.8) ou https://github.com/hideakitai/MPU9250
**Étapes :
***Réaliser la calibration et noter les valeurs affichées,
***les entrer dans votre programme (fonctions setMagBias() et setMagScale()
***Pour réaliser une mesure, se servir des programmes d'exemples
*Robot Arrex :
** [[Cours:RobotArrex]] (section documents)
** avec shield moteur

==Fichiers/Images==

*[[Image:CircuitBUT2.png|250px]]

==liens (dont règlement concours) ==
* concours robotique Cachan, lien vers le règlement en pdf : https://www.festivalrobotiquecachan.fr/wp-content/uploads/Reglement_rencontres_de_robotique_GEII_BUT-1-2-3.pdf
* [[Media:FRC2024-Guideparticipant-v1.01.pdf|Organisation du concours]]
*[[Cours:archive SAÉ robot joueur de tennis]]
*[[Cours:archive SAÉ suivi de ligne]]
*https://www.youtube.com/watch?v=xH8EIqh-2_Y

Cours:SaeRobotiqueSuiviLigne

2026-05-27T07:54:12Z

Bjacquot : /* Ressources */

=Utiliser des librairies arduino avec un main =

[[Cours:ArduinoSansLoopSetup|Arduino sans loop/setup]]

Un certain nombre de librairies utilisent les fontions arduino [https://github.com/arduino/ArduinoCore-avr/blob/master/cores/arduino/wiring.c delay/delayMicroseconds/millis/micros]

Ces fonctions utilisent le Timer0 et en particulier l'interruption de débordement.

Ce Timer est configuré dans la fonction [https://github.com/arduino/ArduinoCore-avr/blob/master/cores/arduino/wiring.c init()], qui est appelée dans le [https://github.com/arduino/ArduinoCore-avr/blob/master/cores/arduino/main.cpp "main arduino"]

{|
|-
|
On peut donc initialiser ce Timer0 pour qu'il génère un débordement tel qu'attendu.

Ainsi les fonctions de gestion du temps Arduino peuvent fonctionner comme prévu et on peut ainsi utiliser les librairies qui en dépendent :

<source lang=cpp>
void initFonctionsTempsArduino()
{
sei();
// marche pour 328p et 2560 et autres ...
// à adapter suivant le µc
// cf https://github.com/arduino/ArduinoCore-avr/blob/master/cores/arduino/wiring.c
TCCR0A=(1<<WGM01)|(1<<WGM00);
TCCR0B=(1<<CS01)|(1<<CS00);
TIMSK0=(1<<TOIE0);
}

int main()
{
initFonctionsTempsArduino();
Serial.begin(115200);
while(1)
{
delay(100);
Serial.println(millis());
}
}
</source>

||
<source lang=cpp>
/*
Exemple pour le capteur vl53l1x :
cf exemple de la librairie pour des commentaires
*/
#include <Wire.h>
#include <VL53L1X.h>
VL53L1X sensor;

void initFonctionsTempsArduino()
{
sei();
// marche pour 328p et 2560 et autres ...
// à adapter suivant le µc
// cf https://github.com/arduino/ArduinoCore-avr/blob/master/cores/arduino/wiring.c
TCCR0A=(1<<WGM01)|(1<<WGM00);
TCCR0B=(1<<CS01)|(1<<CS00);
TIMSK0=(1<<TOIE0);
}

int main()
{
initFonctionsTempsArduino();
while (!Serial) {}
Serial.begin(115200);
Wire.begin();
Wire.setClock(400000); // use 400 kHz I2C
sensor.setTimeout(500);
if (!sensor.init())
{
Serial.println("Failed to detect and initialize sensor!");
while (1);
}
sensor.setDistanceMode(VL53L1X::Long);
sensor.setMeasurementTimingBudget(50000);
sensor.startContinuous(50);
while(1)
{
Serial.print(sensor.read());
if (sensor.timeoutOccurred()) { Serial.print(" TIMEOUT"); }
Serial.println();
}
}
</source>
|}

=Augmenter la rapidité des Lidars=
<source lang=cpp>
sensors[i].setMeasurementTimingBudget(20000);
sensors[i].setDistanceMode(VL53L1X::Short);
sensors[i].startContinuous(20);
sensors[0].read(false);
</source>

= Séquence 1 : tâches élémentaires individuelles =

* Tâches de suivi de ligne (un étudiant sur chaque tâche) :
** suivi de cap avec MPU9250
** suivi avec capteurs photorélectifs (nombre de capteurs à choisir)
** suivi avec Lidar, en suivant un mur sur le côté

* s'arrêter à la fin du parcours

* À faire globalement : câblage robot, sécurité

==Livrable 1==
* faire des recherches pour rendre un dossier par groupe (pour lundi 27/05) expliquant : le pont en H, schéma sécurité et chaque partie (a, b, c)
* évaluation le 24/05 (code + questions + fonctionnement)

= Séquence 2 : tâches complexes individuelles + réalisation shield =

* Tâches de suivi (à modifier)
** Capteurs photoréflectifs : détection de marques à droite (si marque : on tourne à droite à l'intersection, sinon tout droit). Détection des marques à gauche : stop et recul pendant 1 seconde (environ) et on repart (pas d'arrêt sur le second passage)
** Lidar : suivi de mur à gauche ET à droite (priorité en suivi à droite). Faire tomber une première barre, pas la seconde.

* Trois cartes à réaliser (une par étudiant)
** carte avec capteurs photoreflectifs
** carte drivers moteur
** carte shield arduino nano

==Livrable 2==

* évaluation le 02/06 (routage/fabrication)

= Séquence 3 : Fusion des trois tâches et programmation globale=

==Livrable 3 ==

= Rapport final =

* Rapport final :
** '''À envoyer au format pdf par mail avant le DD/MM/YY à HH'''
** Diagramme de Gantt
** diagramme algorithme général
** stratégie de résolution de chaque tâche
** Mini-concours à la fin pour sélectionner le meilleur robot (évaluation des capacités du robot, par étudiant en fonction de l'organisation prévue).
** Chiffrage incluant le matériel ainsi que les ressources humaines.

=Organisation=

*Fonctionnement en trinôme sur 12 jours
**9h-12h
**13h30-16h30
*{{Rouge|Compte rendu écrit quotidien individuel}}
**sera contrôlé chaque matin
**doit indiquer les tâches réalisées la veille
**doit indiquer le travail à réaliser le jour même

=Ressources=

==MPU9250==

on va uniquement utiliser le magnétomètre de l'IMU MPU9250.

Le principe est le suivant :

<source lang=cpp>
#include "MPU9250.h"

MPU9250 mpu;

void initFonctionsTempsArduino()
{
sei();
// marche pour 328p et 2560 et autres ...
// à adapter suivant le µc
// cf https://github.com/arduino/ArduinoCore-avr/blob/master/cores/arduino/wiring.c
TCCR0A=(1<<WGM01)|(1<<WGM00);
TCCR0B=(1<<CS01)|(1<<CS00);
TIMSK0=(1<<TOIE0);
}

int main()
{
sei();
initFonctionsTempsArduino();
Serial.begin(115200);
Wire.begin();

if (!mpu.setup(0x68)) {
while (1) {
Serial.println("MPU connection failed. Please check your connection with `connection_check` example.");
delay(5000);
}
}
// il faudra calibrer le magnétomètre
// les valeurs sont propres à chaque composant
// mpu.setMagBias(-56.47, 59.92, 0);
// mpu.setMagScale(0.98, 1.10, 1);

while(1)
{
// attention, lecture toutes les 15ms max !!!
if ((currentTime-time)>15)
{
if (mpu.available())
{
mpu.update_mag();
print_mag();
}
}
}

void print_mag() {
Serial.print("angle, Hx, Hy : ");
float angle=0;
Serial.print(angle,2);
Serial.print(" , ");
Serial.print(mpu.getMagX(), 2);
Serial.print(" , ");
Serial.println(mpu.getMagY(), 2);
}
</source>

==Composants/cartes==
*[[Cours:capteurPhotoReflectif|capteur '''photoréflectif''' pour détection de la {{Rouge|ligne}}]]
*convertisseur de niveau:
**https://www.eeweb.com/level-shifting-techniques-in-i2c-bus-design/
*Batterie LiFePo4
**assemblage de 4 éléments LiFePo4
**documentation sur les cellules [[Media:CellulesLiFePo4.pdf]]
**tensions à ne pas dépasser :
***maximum : 3,45V/élément
***minimum : 2,65V/élément
***ne pas démarrer le robot : 2,85V/élément
*divers
**Commutateur d'arrêt d'urgence https://fr.farnell.com/idec/yw1b-v4e01r/commut-bp-e-stop-spst-nc-10a-120v/dp/2833849?ost=2833849
**Régulateur ajustable 1,25 à 30 Vcc https://www.gotronic.fr/art-regulateur-ajustable-1-25-a-30-vcc-gt134-26094.htm
*driver de moteur
**https://www.cytron.io/p-13amp-6v-30v-dc-motor-driver
*capteurs de distance/contact
**HC-SR04 cf fiche technique sur la page : https://www.gotronic.fr/art-module-de-detection-us-hc-sr04-20912.htm
**VL53L1X
***https://www.robotshop.com/eu/fr/platine-deploiement-capteur-distance-tof-regulateur-tension-vl53l1x.html
***https://github.com/pololu/vl53l1x-arduino
**Mini Microrupteur - SPDT https://www.robotshop.com/eu/fr/mini-microrupteur-spdt-levier-rouleau.html
**GP2Yxxxx https://www.gotronic.fr/art-capteur-de-mesure-sharp-gp2y0a41sk0f-18338.htm
**lidar tfmini-s
***https://www.robotshop.com/eu/fr/module-micro-lidar-tfmini-s-benewake-i2c-12m.html
***https://www.arduino.cc/reference/en/libraries/tfmpi2c/
**lidar Lite 3
***https://www.robotshop.com/eu/fr/capteur-distance-laser-haute-performance-lidar-lite-3-llv3hp.html
***https://github.com/RobotShop/LIDARLite_v3_Arduino_Library
*caméra
**pixyv2
***https://pixycam.com/pixy2/
***[[Cours:TPS_2103_tp_pixy|TP caméra pixy]]
***Avoir un PixyMon plus rapide dans la g.008 :
****utiliser un 2ème poste
****ne pas se connecter sur nomachine
****lancer un terminal
****lancer la commande PixyMon
*IMU
**Explications du principe du capteur mpu9250 : https://learn.sparkfun.com/tutorials/mpu-9250-hookup-guide/all
**Bibliothèque à utiliser : dans le gestionnaire de bibliothèque => ''by hideakitai'' (v 0.4.8) ou https://github.com/hideakitai/MPU9250
**Étapes :
***Réaliser la calibration et noter les valeurs affichées,
***les entrer dans votre programme (fonctions setMagBias() et setMagScale()
***Pour réaliser une mesure, se servir des programmes d'exemples
*Robot Arrex :
** [[Cours:RobotArrex]] (section documents)
** avec shield moteur

==Fichiers/Images==

*[[Image:CircuitBUT2.png|250px]]

==liens (dont règlement concours) ==
* concours robotique Cachan, lien vers le règlement en pdf : https://www.festivalrobotiquecachan.fr/wp-content/uploads/Reglement_rencontres_de_robotique_GEII_BUT-1-2-3.pdf
* [[Media:FRC2024-Guideparticipant-v1.01.pdf|Organisation du concours]]
*[[Cours:archive SAÉ robot joueur de tennis]]
*[[Cours:archive SAÉ suivi de ligne]]
*https://www.youtube.com/watch?v=xH8EIqh-2_Y

Cours:SaeRobotique

2026-05-15T17:36:30Z

Bjacquot :

[[Cours:SaeRobotique correction|{{Vert|<big><big>Corrections enseignants</big></big>}}]]

[[Cours:SaeRobotiqueSuiviLigne]]

[[Cours:SaeRobotiqueTennis]]

=Ressources communes=

==structure du programme==

Vous pourrez utiliser la structure de programme suivante :

<source lang=cpp>
enum state {etapeInit,etapeChercheBalle,etapeDeplacementVersBalle};

state etapeSuivante=etapeInit;
state etapeActive=etapeInit;

int main()
{
while(1)
{
// lecture des capteurs en début de boucle
switch (etapeActive)
{
case etapeInit:

// si ... etapeSuivante=
break;
case etapeChercheBalle:

// si ... etapeSuivante=
break;
case etapeDeplacementVersBalle:

// si ... etapeSuivante=
break;
}

// on modifie l'étape active pour la prochaine boucle
etapeActive=etapeSuivante;
}
}
</source>

==Programmation : comment faire==

===Exécuter une action une seule fois :===
<source lang=cpp>
while(1)
{
static bool dejaFait=false;
if (dejaFait==false)
{
executerMonAction();
dejaFait=true;
}
}
</source>

===Répéter une action régulièrement===
{| class="wikitable"
|-
|
<source lang=cpp>
void initFonctionsTempsArduino()
{
sei();
// marche pour 328p et 2560 et autres ...
// à adapter suivant le µc
// cf https://github.com/arduino/ArduinoCore-avr/blob/master/cores/arduino/wiring.c
TCCR0A=(1<<WGM01)|(1<<WGM00);
TCCR0B=(1<<CS01)|(1<<CS00);
TIMSK0=(1<<TOIE0);
}

int main()
{
initFonctionsTempsArduino();
while(1)
{
static uint32_t triggerTime=millis();
uint32_t currentTime=millis();
if (currentTime>=triggerTime)
{
faireMonAction();
triggerTime += 500; // prochaine exécution dans 500ms
}
}
}
</source>
||
<source lang=cpp>
void initFonctionsTempsArduino()
{
sei();
// marche pour 328p et 2560 et autres ...
// à adapter suivant le µc
// cf https://github.com/arduino/ArduinoCore-avr/blob/master/cores/arduino/wiring.c
TCCR0A=(1<<WGM01)|(1<<WGM00);
TCCR0B=(1<<CS01)|(1<<CS00);
TIMSK0=(1<<TOIE0);
}

int main()
{
initFonctionsTempsArduino();
while(1)
{
static uint32_t triggerTime=0;
uint32_t currentTime=millis();

switch (etapeActive)
{
case etapeX:
if ( qqch)
{
etapeSuivante=etapeY;
triggerTime=currentTime;
}
break;
case etapeY:
if ( currentTime >= (triggerTime + duree ) )
{
etapeSuivante=etapeZ;
}
break;
case etapeZ:
...
break;
}
etapeActive=etapeSuivante;
}
}
</source>
|}

===Affichage provisoire pour deboggage===

{|
|-
|
<source lang=cpp>
#define debug // mode debug
//ou
#undef debug // mode sans debug

int main()
{
...
while(1)
{
#ifdef debug
Serial.println("juste si debug");
#endif
}
}

</source>
||
<source lang=cpp>
#define DEBUG //If you comment this line, the DEBUG_PRINT & DEBUG_PRINTLN lines are defined as blank.
#ifdef DEBUG //Macros are usually in all capital letters.
#define DEBUG_PRINT(...) Serial.print(__VA_ARGS__) //DEBUG_PRINT is a macro, debug print
#define DEBUG_PRINTLN(...) Serial.println(__VA_ARGS__) //DEBUG_PRINTLN is a macro, debug print with new line
#else
#define DEBUG_PRINT(...) //now defines a blank line
#define DEBUG_PRINTLN(...) //now defines a blank line
#endif
int main()
{
while(1)
{
DEBUG_PRINTLN("juste si debug");
}
}

</source>
|}

===changement d'état d'un capteur===

{|
|-
! au front montant d'un capteur !! 1x si le capteur est actif suffisamment longtemps
|-
| <source lang=cpp>
bool valeurActuelle=valeurInit;
bool valeurPrecedente=valeurInit;

...
int main()
{
...
while(1)
{
valeurPrecedente=valeurActuelle;
valeurActuelle=lireValeurCapteur();
if ( (valeurPrecedente==false) and (valeurActuelle==true) )
{
// action, par ex:
nombreFrontMontant++;
}
}
}
</source>
|| <source lang=cpp>
bool valeurActuelle=valeurInit;
int8_t dureeActif=0;
bool isFront=true;

...
int main()
{
...
while(1)
{
valeurActuelle=lireValeurCapteur();
if (valeurActuelle==true)
{
if (dureeActif>=20)
{
// faire l'action, par ex
if (isFront==true)
{
isFront=false;
nombreFrontMontant++;
}
}
else dureeActif++;
}
else
{
dureeActif=0;
isFront=true;
}
}
}
</source>
|}

===filtrer un capteur tor===

{| class="wikitable"
|-
! filtrer un capteur TOR !! sous forme de fonction pour filtrage de plusieurs capteurs
|-
| <source lang=cpp>

bool rawValue=readCapteur();
static bool value=false;

const uint8_t filterValue=12;
static uint8_t nbTrue=0;
static uint8_t nbFalse=0;

if ( rawValue )
{
if ( nbTrue>= filterValue)
{
value=true;
nbFalse=0;
}
else nbTrue++;
}
else
{
if ( nbFalse>= filterValue)
{
value=false;
nbTrue=0;
}
else nbFalse++;
}
</source>
|| <source lang=cpp>
void filtreTor(bool rawValue,bool & value,uint8_t filterValue,uint8_t & nbTrue,uint8_t & nbFalse)
{
if ( rawValue )
{
if ( nbTrue>= filterValue)
{
value=true;
nbFalse=0;
}
else nbTrue++;
}
else
{
if ( nbFalse>= filterValue)
{
value=false;
nbTrue=0;
}
else nbFalse++;
}
}

int main()
{
...
bool rawValue=rawValueTab[i];
static bool value=false;

const uint8_t filterValue=5;
static uint8_t nbTrue=0;
static uint8_t nbFalse=0;
filtreTor(rawValue,value,filterValue,nbTrue,nbFalse);
...
}
</source>
|}

===Optimiser l'exécution d'une fonction===
<source lang=cpp>
inline void setVitesse(int16_t vmG, int16_t vmD) __attribute__((always_inline));

void setVitesse(int16_t vmG, int16_t vmD)
{
// code de la fonction
...
}

</source>

==Diagramme d'état==

Pour aller plus loin dans la programmation sous forme de [https://fr.wikipedia.org/wiki/Automate_fini {{Rouge|machine à état fini]}}, vous utiliserez comme base le programme suivant :

[[Media:TestFiniteStateMachine.zip]]

==Composants Kicad==

*Résistances :
**symbole R
**boitier suivant la valeur : 1206(CMS)/Axial DIN0309 (traversant)
*Condensateur
**symbole C
**boitier suivant la valeur 1206(CMS)
*VNH7070
**télécharger et décompresser le fichier [[Media:VNH7070BASTR.zip]]
**ajouter la librairie en suivante la page : https://www.snapeda.com/about/import/#KiCad6
**{{Rouge|attention}} : pour l'ajout de la librairie de l'empreinte, indique comme "pseudo nom" {{Rouge|VNH7070BASTR}}
**modèle 3d
***ajouter le fichier VNH7070BASTR.step
***faire une rotation sur X de 90°
*Arduino Nano
**symbole Arduino_Nano_v2.x
**modèle 3d
***télécharger et décompresser : [[Media:Arduino_nano.STEP.zip]]
***dans les propriétés de la carte (éditeur de pcb), onglet modèle 3d
****ajouter le fichier téléchargé
****rotation X 90
****rotation Z -90
****décalage Z 11mm
***ajouter 2 barrettes M/F
***${KICAD9_3DMODEL_DIR}/Connector_PinSocket_2.54mm.3dshapes/PinSocket_1x15_P2.54mm_Vertical.step
***décaler le 2ème en X de 15,24mm
*bornier à vis : Screw_Terminal_01x02
*MPU-9250
**mettre 2 barrettes sécables 4 contacts, espacées de 6 pas
**[[Media:SparkFun MPU-9250 Breakout.step.zip]]
*convertisseur de niveau
**convertisseur {{Rouge|gt1167}}
***utiliser la librairie : [[Media:GT117.zip]]
***documentation : [[Media:Gt1167.pdf]]
**convertisseur [https://www.sparkfun.com/sparkfun-logic-level-converter-bi-directional.html sparkfun {{Rouge|BOB-12009}}]
***utiliser la librairie : [[Media:BOB-12009.zip]]
***modèle 3d :
****BOB-12009.step
*****rotation 90/0/0
*****translation 0/0/9
****ajouter 2 barrettes M/F : ${KICAD9_3DMODEL_DIR}/Connector_PinSocket_2.54mm.3dshapes/PinSocket_1x06_P2.54mm_Vertical.step
*****rotation 0/0/0
*****translation 5.08/6.35/0 et -5.08/6.35/0
*Autres : [[Media:SaeS2_2025.zip]]
*GroveH : [[Media:groveH.zip]]
*Connecteur à vis : [[Media:1729131.zip]]

Fichier:Gt1167.pdf

2026-05-15T17:36:09Z

Bjacquot :

Cours:SaeRobotique

2026-05-15T17:35:56Z

Bjacquot : /* Composants Kicad */

[[Cours:SaeRobotique correction|{{Vert|<big><big>Corrections enseignants</big></big>}}]]

[[Cours:SaeRobotiqueSuiviLigne]]

[[Cours:SaeRobotiqueTennis]]

=Ressources communes=

==structure du programme==

Vous pourrez utiliser la structure de programme suivante :

<source lang=cpp>
enum state {etapeInit,etapeChercheBalle,etapeDeplacementVersBalle};

state etapeSuivante=etapeInit;
state etapeActive=etapeInit;

int main()
{
while(1)
{
// lecture des capteurs en début de boucle
switch (etapeActive)
{
case etapeInit:

// si ... etapeSuivante=
break;
case etapeChercheBalle:

// si ... etapeSuivante=
break;
case etapeDeplacementVersBalle:

// si ... etapeSuivante=
break;
}

// on modifie l'étape active pour la prochaine boucle
etapeActive=etapeSuivante;
}
}
</source>

==Programmation : comment faire==

===Exécuter une action une seule fois :===
<source lang=cpp>
while(1)
{
static bool dejaFait=false;
if (dejaFait==false)
{
executerMonAction();
dejaFait=true;
}
}
</source>

===Répéter une action régulièrement===
{| class="wikitable"
|-
|
<source lang=cpp>
void initFonctionsTempsArduino()
{
sei();
// marche pour 328p et 2560 et autres ...
// à adapter suivant le µc
// cf https://github.com/arduino/ArduinoCore-avr/blob/master/cores/arduino/wiring.c
TCCR0A=(1<<WGM01)|(1<<WGM00);
TCCR0B=(1<<CS01)|(1<<CS00);
TIMSK0=(1<<TOIE0);
}

int main()
{
initFonctionsTempsArduino();
while(1)
{
static uint32_t triggerTime=millis();
uint32_t currentTime=millis();
if (currentTime>=triggerTime)
{
faireMonAction();
triggerTime += 500; // prochaine exécution dans 500ms
}
}
}
</source>
||
<source lang=cpp>
void initFonctionsTempsArduino()
{
sei();
// marche pour 328p et 2560 et autres ...
// à adapter suivant le µc
// cf https://github.com/arduino/ArduinoCore-avr/blob/master/cores/arduino/wiring.c
TCCR0A=(1<<WGM01)|(1<<WGM00);
TCCR0B=(1<<CS01)|(1<<CS00);
TIMSK0=(1<<TOIE0);
}

int main()
{
initFonctionsTempsArduino();
while(1)
{
static uint32_t triggerTime=0;
uint32_t currentTime=millis();

switch (etapeActive)
{
case etapeX:
if ( qqch)
{
etapeSuivante=etapeY;
triggerTime=currentTime;
}
break;
case etapeY:
if ( currentTime >= (triggerTime + duree ) )
{
etapeSuivante=etapeZ;
}
break;
case etapeZ:
...
break;
}
etapeActive=etapeSuivante;
}
}
</source>
|}

===Affichage provisoire pour deboggage===

{|
|-
|
<source lang=cpp>
#define debug // mode debug
//ou
#undef debug // mode sans debug

int main()
{
...
while(1)
{
#ifdef debug
Serial.println("juste si debug");
#endif
}
}

</source>
||
<source lang=cpp>
#define DEBUG //If you comment this line, the DEBUG_PRINT & DEBUG_PRINTLN lines are defined as blank.
#ifdef DEBUG //Macros are usually in all capital letters.
#define DEBUG_PRINT(...) Serial.print(__VA_ARGS__) //DEBUG_PRINT is a macro, debug print
#define DEBUG_PRINTLN(...) Serial.println(__VA_ARGS__) //DEBUG_PRINTLN is a macro, debug print with new line
#else
#define DEBUG_PRINT(...) //now defines a blank line
#define DEBUG_PRINTLN(...) //now defines a blank line
#endif
int main()
{
while(1)
{
DEBUG_PRINTLN("juste si debug");
}
}

</source>
|}

===changement d'état d'un capteur===

{|
|-
! au front montant d'un capteur !! 1x si le capteur est actif suffisamment longtemps
|-
| <source lang=cpp>
bool valeurActuelle=valeurInit;
bool valeurPrecedente=valeurInit;

...
int main()
{
...
while(1)
{
valeurPrecedente=valeurActuelle;
valeurActuelle=lireValeurCapteur();
if ( (valeurPrecedente==false) and (valeurActuelle==true) )
{
// action, par ex:
nombreFrontMontant++;
}
}
}
</source>
|| <source lang=cpp>
bool valeurActuelle=valeurInit;
int8_t dureeActif=0;
bool isFront=true;

...
int main()
{
...
while(1)
{
valeurActuelle=lireValeurCapteur();
if (valeurActuelle==true)
{
if (dureeActif>=20)
{
// faire l'action, par ex
if (isFront==true)
{
isFront=false;
nombreFrontMontant++;
}
}
else dureeActif++;
}
else
{
dureeActif=0;
isFront=true;
}
}
}
</source>
|}

===filtrer un capteur tor===

{| class="wikitable"
|-
! filtrer un capteur TOR !! sous forme de fonction pour filtrage de plusieurs capteurs
|-
| <source lang=cpp>

bool rawValue=readCapteur();
static bool value=false;

const uint8_t filterValue=12;
static uint8_t nbTrue=0;
static uint8_t nbFalse=0;

if ( rawValue )
{
if ( nbTrue>= filterValue)
{
value=true;
nbFalse=0;
}
else nbTrue++;
}
else
{
if ( nbFalse>= filterValue)
{
value=false;
nbTrue=0;
}
else nbFalse++;
}
</source>
|| <source lang=cpp>
void filtreTor(bool rawValue,bool & value,uint8_t filterValue,uint8_t & nbTrue,uint8_t & nbFalse)
{
if ( rawValue )
{
if ( nbTrue>= filterValue)
{
value=true;
nbFalse=0;
}
else nbTrue++;
}
else
{
if ( nbFalse>= filterValue)
{
value=false;
nbTrue=0;
}
else nbFalse++;
}
}

int main()
{
...
bool rawValue=rawValueTab[i];
static bool value=false;

const uint8_t filterValue=5;
static uint8_t nbTrue=0;
static uint8_t nbFalse=0;
filtreTor(rawValue,value,filterValue,nbTrue,nbFalse);
...
}
</source>
|}

===Optimiser l'exécution d'une fonction===
<source lang=cpp>
inline void setVitesse(int16_t vmG, int16_t vmD) __attribute__((always_inline));

void setVitesse(int16_t vmG, int16_t vmD)
{
// code de la fonction
...
}

</source>

==Diagramme d'état==

Pour aller plus loin dans la programmation sous forme de [https://fr.wikipedia.org/wiki/Automate_fini {{Rouge|machine à état fini]}}, vous utiliserez comme base le programme suivant :

[[Media:TestFiniteStateMachine.zip]]

==Composants Kicad==

*Résistances :
**symbole R
**boitier suivant la valeur : 1206(CMS)/Axial DIN0309 (traversant)
*Condensateur
**symbole C
**boitier suivant la valeur 1206(CMS)
*VNH7070
**télécharger et décompresser le fichier [[Media:VNH7070BASTR.zip]]
**ajouter la librairie en suivante la page : https://www.snapeda.com/about/import/#KiCad6
**{{Rouge|attention}} : pour l'ajout de la librairie de l'empreinte, indique comme "pseudo nom" {{Rouge|VNH7070BASTR}}
**modèle 3d
***ajouter le fichier VNH7070BASTR.step
***faire une rotation sur X de 90°
*Arduino Nano
**symbole Arduino_Nano_v2.x
**modèle 3d
***télécharger et décompresser : [[Media:Arduino_nano.STEP.zip]]
***dans les propriétés de la carte (éditeur de pcb), onglet modèle 3d
****ajouter le fichier téléchargé
****rotation X 90
****rotation Z -90
****décalage Z 11mm
***ajouter 2 barrettes M/F
***${KICAD9_3DMODEL_DIR}/Connector_PinSocket_2.54mm.3dshapes/PinSocket_1x15_P2.54mm_Vertical.step
***décaler le 2ème en X de 15,24mm
*bornier à vis : Screw_Terminal_01x02
*MPU-9250
**mettre 2 barrettes sécables 4 contacts, espacées de 6 pas
**[[Media:SparkFun MPU-9250 Breakout.step.zip]]
*convertisseur de niveau
**convertisseur {{Rouge|gt1167}}
***utiliser la librairie : [[Media:GT117.zip]]
***
**convertisseur [https://www.sparkfun.com/sparkfun-logic-level-converter-bi-directional.html sparkfun {{Rouge|BOB-12009}}]
***utiliser la librairie : [[Media:BOB-12009.zip]]
***modèle 3d :
****BOB-12009.step
*****rotation 90/0/0
*****translation 0/0/9
****ajouter 2 barrettes M/F : ${KICAD9_3DMODEL_DIR}/Connector_PinSocket_2.54mm.3dshapes/PinSocket_1x06_P2.54mm_Vertical.step
*****rotation 0/0/0
*****translation 5.08/6.35/0 et -5.08/6.35/0
*Autres : [[Media:SaeS2_2025.zip]]
*GroveH : [[Media:groveH.zip]]
*Connecteur à vis : [[Media:1729131.zip]]

Cours:SaeRobotique

2026-05-15T17:34:53Z

Bjacquot : /* Composants Kicad */

[[Cours:SaeRobotique correction|{{Vert|<big><big>Corrections enseignants</big></big>}}]]

[[Cours:SaeRobotiqueSuiviLigne]]

[[Cours:SaeRobotiqueTennis]]

=Ressources communes=

==structure du programme==

Vous pourrez utiliser la structure de programme suivante :

<source lang=cpp>
enum state {etapeInit,etapeChercheBalle,etapeDeplacementVersBalle};

state etapeSuivante=etapeInit;
state etapeActive=etapeInit;

int main()
{
while(1)
{
// lecture des capteurs en début de boucle
switch (etapeActive)
{
case etapeInit:

// si ... etapeSuivante=
break;
case etapeChercheBalle:

// si ... etapeSuivante=
break;
case etapeDeplacementVersBalle:

// si ... etapeSuivante=
break;
}

// on modifie l'étape active pour la prochaine boucle
etapeActive=etapeSuivante;
}
}
</source>

==Programmation : comment faire==

===Exécuter une action une seule fois :===
<source lang=cpp>
while(1)
{
static bool dejaFait=false;
if (dejaFait==false)
{
executerMonAction();
dejaFait=true;
}
}
</source>

===Répéter une action régulièrement===
{| class="wikitable"
|-
|
<source lang=cpp>
void initFonctionsTempsArduino()
{
sei();
// marche pour 328p et 2560 et autres ...
// à adapter suivant le µc
// cf https://github.com/arduino/ArduinoCore-avr/blob/master/cores/arduino/wiring.c
TCCR0A=(1<<WGM01)|(1<<WGM00);
TCCR0B=(1<<CS01)|(1<<CS00);
TIMSK0=(1<<TOIE0);
}

int main()
{
initFonctionsTempsArduino();
while(1)
{
static uint32_t triggerTime=millis();
uint32_t currentTime=millis();
if (currentTime>=triggerTime)
{
faireMonAction();
triggerTime += 500; // prochaine exécution dans 500ms
}
}
}
</source>
||
<source lang=cpp>
void initFonctionsTempsArduino()
{
sei();
// marche pour 328p et 2560 et autres ...
// à adapter suivant le µc
// cf https://github.com/arduino/ArduinoCore-avr/blob/master/cores/arduino/wiring.c
TCCR0A=(1<<WGM01)|(1<<WGM00);
TCCR0B=(1<<CS01)|(1<<CS00);
TIMSK0=(1<<TOIE0);
}

int main()
{
initFonctionsTempsArduino();
while(1)
{
static uint32_t triggerTime=0;
uint32_t currentTime=millis();

switch (etapeActive)
{
case etapeX:
if ( qqch)
{
etapeSuivante=etapeY;
triggerTime=currentTime;
}
break;
case etapeY:
if ( currentTime >= (triggerTime + duree ) )
{
etapeSuivante=etapeZ;
}
break;
case etapeZ:
...
break;
}
etapeActive=etapeSuivante;
}
}
</source>
|}

===Affichage provisoire pour deboggage===

{|
|-
|
<source lang=cpp>
#define debug // mode debug
//ou
#undef debug // mode sans debug

int main()
{
...
while(1)
{
#ifdef debug
Serial.println("juste si debug");
#endif
}
}

</source>
||
<source lang=cpp>
#define DEBUG //If you comment this line, the DEBUG_PRINT & DEBUG_PRINTLN lines are defined as blank.
#ifdef DEBUG //Macros are usually in all capital letters.
#define DEBUG_PRINT(...) Serial.print(__VA_ARGS__) //DEBUG_PRINT is a macro, debug print
#define DEBUG_PRINTLN(...) Serial.println(__VA_ARGS__) //DEBUG_PRINTLN is a macro, debug print with new line
#else
#define DEBUG_PRINT(...) //now defines a blank line
#define DEBUG_PRINTLN(...) //now defines a blank line
#endif
int main()
{
while(1)
{
DEBUG_PRINTLN("juste si debug");
}
}

</source>
|}

===changement d'état d'un capteur===

{|
|-
! au front montant d'un capteur !! 1x si le capteur est actif suffisamment longtemps
|-
| <source lang=cpp>
bool valeurActuelle=valeurInit;
bool valeurPrecedente=valeurInit;

...
int main()
{
...
while(1)
{
valeurPrecedente=valeurActuelle;
valeurActuelle=lireValeurCapteur();
if ( (valeurPrecedente==false) and (valeurActuelle==true) )
{
// action, par ex:
nombreFrontMontant++;
}
}
}
</source>
|| <source lang=cpp>
bool valeurActuelle=valeurInit;
int8_t dureeActif=0;
bool isFront=true;

...
int main()
{
...
while(1)
{
valeurActuelle=lireValeurCapteur();
if (valeurActuelle==true)
{
if (dureeActif>=20)
{
// faire l'action, par ex
if (isFront==true)
{
isFront=false;
nombreFrontMontant++;
}
}
else dureeActif++;
}
else
{
dureeActif=0;
isFront=true;
}
}
}
</source>
|}

===filtrer un capteur tor===

{| class="wikitable"
|-
! filtrer un capteur TOR !! sous forme de fonction pour filtrage de plusieurs capteurs
|-
| <source lang=cpp>

bool rawValue=readCapteur();
static bool value=false;

const uint8_t filterValue=12;
static uint8_t nbTrue=0;
static uint8_t nbFalse=0;

if ( rawValue )
{
if ( nbTrue>= filterValue)
{
value=true;
nbFalse=0;
}
else nbTrue++;
}
else
{
if ( nbFalse>= filterValue)
{
value=false;
nbTrue=0;
}
else nbFalse++;
}
</source>
|| <source lang=cpp>
void filtreTor(bool rawValue,bool & value,uint8_t filterValue,uint8_t & nbTrue,uint8_t & nbFalse)
{
if ( rawValue )
{
if ( nbTrue>= filterValue)
{
value=true;
nbFalse=0;
}
else nbTrue++;
}
else
{
if ( nbFalse>= filterValue)
{
value=false;
nbTrue=0;
}
else nbFalse++;
}
}

int main()
{
...
bool rawValue=rawValueTab[i];
static bool value=false;

const uint8_t filterValue=5;
static uint8_t nbTrue=0;
static uint8_t nbFalse=0;
filtreTor(rawValue,value,filterValue,nbTrue,nbFalse);
...
}
</source>
|}

===Optimiser l'exécution d'une fonction===
<source lang=cpp>
inline void setVitesse(int16_t vmG, int16_t vmD) __attribute__((always_inline));

void setVitesse(int16_t vmG, int16_t vmD)
{
// code de la fonction
...
}

</source>

==Diagramme d'état==

Pour aller plus loin dans la programmation sous forme de [https://fr.wikipedia.org/wiki/Automate_fini {{Rouge|machine à état fini]}}, vous utiliserez comme base le programme suivant :

[[Media:TestFiniteStateMachine.zip]]

==Composants Kicad==

*Résistances :
**symbole R
**boitier suivant la valeur : 1206(CMS)/Axial DIN0309 (traversant)
*Condensateur
**symbole C
**boitier suivant la valeur 1206(CMS)
*VNH7070
**télécharger et décompresser le fichier [[Media:VNH7070BASTR.zip]]
**ajouter la librairie en suivante la page : https://www.snapeda.com/about/import/#KiCad6
**{{Rouge|attention}} : pour l'ajout de la librairie de l'empreinte, indique comme "pseudo nom" {{Rouge|VNH7070BASTR}}
**modèle 3d
***ajouter le fichier VNH7070BASTR.step
***faire une rotation sur X de 90°
*Arduino Nano
**symbole Arduino_Nano_v2.x
**modèle 3d
***télécharger et décompresser : [[Media:Arduino_nano.STEP.zip]]
***dans les propriétés de la carte (éditeur de pcb), onglet modèle 3d
****ajouter le fichier téléchargé
****rotation X 90
****rotation Z -90
****décalage Z 11mm
***ajouter 2 barrettes M/F
***${KICAD9_3DMODEL_DIR}/Connector_PinSocket_2.54mm.3dshapes/PinSocket_1x15_P2.54mm_Vertical.step
***décaler le 2ème en X de 15,24mm
*bornier à vis : Screw_Terminal_01x02
*MPU-9250
**mettre 2 barrettes sécables 4 contacts, espacées de 6 pas
**[[Media:SparkFun MPU-9250 Breakout.step.zip]]
*convertisseur de niveau
**convertisseur gt1167 :utiliser la librairie : [[Media:GT117.zip]]
**convertisseur [https://www.sparkfun.com/sparkfun-logic-level-converter-bi-directional.html sparkfun BOB-12009]
***utiliser la librairie : [[Media:BOB-12009.zip]]
***modèle 3d :
****BOB-12009.step
*****rotation 90/0/0
*****translation 0/0/9
****ajouter 2 barrettes M/F : ${KICAD9_3DMODEL_DIR}/Connector_PinSocket_2.54mm.3dshapes/PinSocket_1x06_P2.54mm_Vertical.step
*****rotation 0/0/0
*****translation 5.08/6.35/0 et -5.08/6.35/0
*Autres : [[Media:SaeS2_2025.zip]]
*GroveH : [[Media:groveH.zip]]
*Connecteur à vis : [[Media:1729131.zip]]

Cours:SaeRobotique

2026-05-15T17:34:36Z

Bjacquot : /* Composants Kicad */

[[Cours:SaeRobotique correction|{{Vert|<big><big>Corrections enseignants</big></big>}}]]

[[Cours:SaeRobotiqueSuiviLigne]]

[[Cours:SaeRobotiqueTennis]]

=Ressources communes=

==structure du programme==

Vous pourrez utiliser la structure de programme suivante :

<source lang=cpp>
enum state {etapeInit,etapeChercheBalle,etapeDeplacementVersBalle};

state etapeSuivante=etapeInit;
state etapeActive=etapeInit;

int main()
{
while(1)
{
// lecture des capteurs en début de boucle
switch (etapeActive)
{
case etapeInit:

// si ... etapeSuivante=
break;
case etapeChercheBalle:

// si ... etapeSuivante=
break;
case etapeDeplacementVersBalle:

// si ... etapeSuivante=
break;
}

// on modifie l'étape active pour la prochaine boucle
etapeActive=etapeSuivante;
}
}
</source>

==Programmation : comment faire==

===Exécuter une action une seule fois :===
<source lang=cpp>
while(1)
{
static bool dejaFait=false;
if (dejaFait==false)
{
executerMonAction();
dejaFait=true;
}
}
</source>

===Répéter une action régulièrement===
{| class="wikitable"
|-
|
<source lang=cpp>
void initFonctionsTempsArduino()
{
sei();
// marche pour 328p et 2560 et autres ...
// à adapter suivant le µc
// cf https://github.com/arduino/ArduinoCore-avr/blob/master/cores/arduino/wiring.c
TCCR0A=(1<<WGM01)|(1<<WGM00);
TCCR0B=(1<<CS01)|(1<<CS00);
TIMSK0=(1<<TOIE0);
}

int main()
{
initFonctionsTempsArduino();
while(1)
{
static uint32_t triggerTime=millis();
uint32_t currentTime=millis();
if (currentTime>=triggerTime)
{
faireMonAction();
triggerTime += 500; // prochaine exécution dans 500ms
}
}
}
</source>
||
<source lang=cpp>
void initFonctionsTempsArduino()
{
sei();
// marche pour 328p et 2560 et autres ...
// à adapter suivant le µc
// cf https://github.com/arduino/ArduinoCore-avr/blob/master/cores/arduino/wiring.c
TCCR0A=(1<<WGM01)|(1<<WGM00);
TCCR0B=(1<<CS01)|(1<<CS00);
TIMSK0=(1<<TOIE0);
}

int main()
{
initFonctionsTempsArduino();
while(1)
{
static uint32_t triggerTime=0;
uint32_t currentTime=millis();

switch (etapeActive)
{
case etapeX:
if ( qqch)
{
etapeSuivante=etapeY;
triggerTime=currentTime;
}
break;
case etapeY:
if ( currentTime >= (triggerTime + duree ) )
{
etapeSuivante=etapeZ;
}
break;
case etapeZ:
...
break;
}
etapeActive=etapeSuivante;
}
}
</source>
|}

===Affichage provisoire pour deboggage===

{|
|-
|
<source lang=cpp>
#define debug // mode debug
//ou
#undef debug // mode sans debug

int main()
{
...
while(1)
{
#ifdef debug
Serial.println("juste si debug");
#endif
}
}

</source>
||
<source lang=cpp>
#define DEBUG //If you comment this line, the DEBUG_PRINT & DEBUG_PRINTLN lines are defined as blank.
#ifdef DEBUG //Macros are usually in all capital letters.
#define DEBUG_PRINT(...) Serial.print(__VA_ARGS__) //DEBUG_PRINT is a macro, debug print
#define DEBUG_PRINTLN(...) Serial.println(__VA_ARGS__) //DEBUG_PRINTLN is a macro, debug print with new line
#else
#define DEBUG_PRINT(...) //now defines a blank line
#define DEBUG_PRINTLN(...) //now defines a blank line
#endif
int main()
{
while(1)
{
DEBUG_PRINTLN("juste si debug");
}
}

</source>
|}

===changement d'état d'un capteur===

{|
|-
! au front montant d'un capteur !! 1x si le capteur est actif suffisamment longtemps
|-
| <source lang=cpp>
bool valeurActuelle=valeurInit;
bool valeurPrecedente=valeurInit;

...
int main()
{
...
while(1)
{
valeurPrecedente=valeurActuelle;
valeurActuelle=lireValeurCapteur();
if ( (valeurPrecedente==false) and (valeurActuelle==true) )
{
// action, par ex:
nombreFrontMontant++;
}
}
}
</source>
|| <source lang=cpp>
bool valeurActuelle=valeurInit;
int8_t dureeActif=0;
bool isFront=true;

...
int main()
{
...
while(1)
{
valeurActuelle=lireValeurCapteur();
if (valeurActuelle==true)
{
if (dureeActif>=20)
{
// faire l'action, par ex
if (isFront==true)
{
isFront=false;
nombreFrontMontant++;
}
}
else dureeActif++;
}
else
{
dureeActif=0;
isFront=true;
}
}
}
</source>
|}

===filtrer un capteur tor===

{| class="wikitable"
|-
! filtrer un capteur TOR !! sous forme de fonction pour filtrage de plusieurs capteurs
|-
| <source lang=cpp>

bool rawValue=readCapteur();
static bool value=false;

const uint8_t filterValue=12;
static uint8_t nbTrue=0;
static uint8_t nbFalse=0;

if ( rawValue )
{
if ( nbTrue>= filterValue)
{
value=true;
nbFalse=0;
}
else nbTrue++;
}
else
{
if ( nbFalse>= filterValue)
{
value=false;
nbTrue=0;
}
else nbFalse++;
}
</source>
|| <source lang=cpp>
void filtreTor(bool rawValue,bool & value,uint8_t filterValue,uint8_t & nbTrue,uint8_t & nbFalse)
{
if ( rawValue )
{
if ( nbTrue>= filterValue)
{
value=true;
nbFalse=0;
}
else nbTrue++;
}
else
{
if ( nbFalse>= filterValue)
{
value=false;
nbTrue=0;
}
else nbFalse++;
}
}

int main()
{
...
bool rawValue=rawValueTab[i];
static bool value=false;

const uint8_t filterValue=5;
static uint8_t nbTrue=0;
static uint8_t nbFalse=0;
filtreTor(rawValue,value,filterValue,nbTrue,nbFalse);
...
}
</source>
|}

===Optimiser l'exécution d'une fonction===
<source lang=cpp>
inline void setVitesse(int16_t vmG, int16_t vmD) __attribute__((always_inline));

void setVitesse(int16_t vmG, int16_t vmD)
{
// code de la fonction
...
}

</source>

==Diagramme d'état==

Pour aller plus loin dans la programmation sous forme de [https://fr.wikipedia.org/wiki/Automate_fini {{Rouge|machine à état fini]}}, vous utiliserez comme base le programme suivant :

[[Media:TestFiniteStateMachine.zip]]

==Composants Kicad==

*Résistances :
**symbole R
**boitier suivant la valeur : 1206(CMS)/Axial DIN0309 (traversant)
*Condensateur
**symbole C
**boitier suivant la valeur 1206(CMS)
*VNH7070
**télécharger et décompresser le fichier [[Media:VNH7070BASTR.zip]]
**ajouter la librairie en suivante la page : https://www.snapeda.com/about/import/#KiCad6
**{{Rouge|attention}} : pour l'ajout de la librairie de l'empreinte, indique comme "pseudo nom" {{Rouge|VNH7070BASTR}}
**modèle 3d
***ajouter le fichier VNH7070BASTR.step
***faire une rotation sur X de 90°
*Arduino Nano
**symbole Arduino_Nano_v2.x
**modèle 3d
***télécharger et décompresser : [[Media:Arduino_nano.STEP.zip]]
***dans les propriétés de la carte (éditeur de pcb), onglet modèle 3d
****ajouter le fichier téléchargé
****rotation X 90
****rotation Z -90
****décalage Z 11mm
***ajouter 2 barrettes M/F
***${KICAD9_3DMODEL_DIR}/Connector_PinSocket_2.54mm.3dshapes/PinSocket_1x15_P2.54mm_Vertical.step
***décaler le 2ème en X de 15,24mm
*bornier à vis : Screw_Terminal_01x02
*MPU-9250
**mettre 2 barrettes sécables 4 contacts, espacées de 6 pas
**[[Media:SparkFun MPU-9250 Breakout.step.zip]]
*convertisseur de niveau
**convertisseur gt1167 :utiliser la librairie : [[Media:GT117.zip]]
*convertisseur [https://www.sparkfun.com/sparkfun-logic-level-converter-bi-directional.html sparkfun BOB-12009]
**utiliser la librairie : [[Media:BOB-12009.zip]]
**modèle 3d :
***BOB-12009.step
****rotation 90/0/0
****translation 0/0/9
***ajouter 2 barrettes M/F : ${KICAD9_3DMODEL_DIR}/Connector_PinSocket_2.54mm.3dshapes/PinSocket_1x06_P2.54mm_Vertical.step
****rotation 0/0/0
****translation 5.08/6.35/0 et -5.08/6.35/0
*Autres : [[Media:SaeS2_2025.zip]]
*GroveH : [[Media:groveH.zip]]
*Connecteur à vis : [[Media:1729131.zip]]

Fichier:GT117.zip

2026-05-15T17:32:27Z

Bjacquot :

Cours:SaeRobotique

2026-05-15T15:38:44Z

Bjacquot : /* Composants Kicad */

[[Cours:SaeRobotique correction|{{Vert|<big><big>Corrections enseignants</big></big>}}]]

[[Cours:SaeRobotiqueSuiviLigne]]

[[Cours:SaeRobotiqueTennis]]

=Ressources communes=

==structure du programme==

Vous pourrez utiliser la structure de programme suivante :

<source lang=cpp>
enum state {etapeInit,etapeChercheBalle,etapeDeplacementVersBalle};

state etapeSuivante=etapeInit;
state etapeActive=etapeInit;

int main()
{
while(1)
{
// lecture des capteurs en début de boucle
switch (etapeActive)
{
case etapeInit:

// si ... etapeSuivante=
break;
case etapeChercheBalle:

// si ... etapeSuivante=
break;
case etapeDeplacementVersBalle:

// si ... etapeSuivante=
break;
}

// on modifie l'étape active pour la prochaine boucle
etapeActive=etapeSuivante;
}
}
</source>

==Programmation : comment faire==

===Exécuter une action une seule fois :===
<source lang=cpp>
while(1)
{
static bool dejaFait=false;
if (dejaFait==false)
{
executerMonAction();
dejaFait=true;
}
}
</source>

===Répéter une action régulièrement===
{| class="wikitable"
|-
|
<source lang=cpp>
void initFonctionsTempsArduino()
{
sei();
// marche pour 328p et 2560 et autres ...
// à adapter suivant le µc
// cf https://github.com/arduino/ArduinoCore-avr/blob/master/cores/arduino/wiring.c
TCCR0A=(1<<WGM01)|(1<<WGM00);
TCCR0B=(1<<CS01)|(1<<CS00);
TIMSK0=(1<<TOIE0);
}

int main()
{
initFonctionsTempsArduino();
while(1)
{
static uint32_t triggerTime=millis();
uint32_t currentTime=millis();
if (currentTime>=triggerTime)
{
faireMonAction();
triggerTime += 500; // prochaine exécution dans 500ms
}
}
}
</source>
||
<source lang=cpp>
void initFonctionsTempsArduino()
{
sei();
// marche pour 328p et 2560 et autres ...
// à adapter suivant le µc
// cf https://github.com/arduino/ArduinoCore-avr/blob/master/cores/arduino/wiring.c
TCCR0A=(1<<WGM01)|(1<<WGM00);
TCCR0B=(1<<CS01)|(1<<CS00);
TIMSK0=(1<<TOIE0);
}

int main()
{
initFonctionsTempsArduino();
while(1)
{
static uint32_t triggerTime=0;
uint32_t currentTime=millis();

switch (etapeActive)
{
case etapeX:
if ( qqch)
{
etapeSuivante=etapeY;
triggerTime=currentTime;
}
break;
case etapeY:
if ( currentTime >= (triggerTime + duree ) )
{
etapeSuivante=etapeZ;
}
break;
case etapeZ:
...
break;
}
etapeActive=etapeSuivante;
}
}
</source>
|}

===Affichage provisoire pour deboggage===

{|
|-
|
<source lang=cpp>
#define debug // mode debug
//ou
#undef debug // mode sans debug

int main()
{
...
while(1)
{
#ifdef debug
Serial.println("juste si debug");
#endif
}
}

</source>
||
<source lang=cpp>
#define DEBUG //If you comment this line, the DEBUG_PRINT & DEBUG_PRINTLN lines are defined as blank.
#ifdef DEBUG //Macros are usually in all capital letters.
#define DEBUG_PRINT(...) Serial.print(__VA_ARGS__) //DEBUG_PRINT is a macro, debug print
#define DEBUG_PRINTLN(...) Serial.println(__VA_ARGS__) //DEBUG_PRINTLN is a macro, debug print with new line
#else
#define DEBUG_PRINT(...) //now defines a blank line
#define DEBUG_PRINTLN(...) //now defines a blank line
#endif
int main()
{
while(1)
{
DEBUG_PRINTLN("juste si debug");
}
}

</source>
|}

===changement d'état d'un capteur===

{|
|-
! au front montant d'un capteur !! 1x si le capteur est actif suffisamment longtemps
|-
| <source lang=cpp>
bool valeurActuelle=valeurInit;
bool valeurPrecedente=valeurInit;

...
int main()
{
...
while(1)
{
valeurPrecedente=valeurActuelle;
valeurActuelle=lireValeurCapteur();
if ( (valeurPrecedente==false) and (valeurActuelle==true) )
{
// action, par ex:
nombreFrontMontant++;
}
}
}
</source>
|| <source lang=cpp>
bool valeurActuelle=valeurInit;
int8_t dureeActif=0;
bool isFront=true;

...
int main()
{
...
while(1)
{
valeurActuelle=lireValeurCapteur();
if (valeurActuelle==true)
{
if (dureeActif>=20)
{
// faire l'action, par ex
if (isFront==true)
{
isFront=false;
nombreFrontMontant++;
}
}
else dureeActif++;
}
else
{
dureeActif=0;
isFront=true;
}
}
}
</source>
|}

===filtrer un capteur tor===

{| class="wikitable"
|-
! filtrer un capteur TOR !! sous forme de fonction pour filtrage de plusieurs capteurs
|-
| <source lang=cpp>

bool rawValue=readCapteur();
static bool value=false;

const uint8_t filterValue=12;
static uint8_t nbTrue=0;
static uint8_t nbFalse=0;

if ( rawValue )
{
if ( nbTrue>= filterValue)
{
value=true;
nbFalse=0;
}
else nbTrue++;
}
else
{
if ( nbFalse>= filterValue)
{
value=false;
nbTrue=0;
}
else nbFalse++;
}
</source>
|| <source lang=cpp>
void filtreTor(bool rawValue,bool & value,uint8_t filterValue,uint8_t & nbTrue,uint8_t & nbFalse)
{
if ( rawValue )
{
if ( nbTrue>= filterValue)
{
value=true;
nbFalse=0;
}
else nbTrue++;
}
else
{
if ( nbFalse>= filterValue)
{
value=false;
nbTrue=0;
}
else nbFalse++;
}
}

int main()
{
...
bool rawValue=rawValueTab[i];
static bool value=false;

const uint8_t filterValue=5;
static uint8_t nbTrue=0;
static uint8_t nbFalse=0;
filtreTor(rawValue,value,filterValue,nbTrue,nbFalse);
...
}
</source>
|}

===Optimiser l'exécution d'une fonction===
<source lang=cpp>
inline void setVitesse(int16_t vmG, int16_t vmD) __attribute__((always_inline));

void setVitesse(int16_t vmG, int16_t vmD)
{
// code de la fonction
...
}

</source>

==Diagramme d'état==

Pour aller plus loin dans la programmation sous forme de [https://fr.wikipedia.org/wiki/Automate_fini {{Rouge|machine à état fini]}}, vous utiliserez comme base le programme suivant :

[[Media:TestFiniteStateMachine.zip]]

==Composants Kicad==

*Résistances :
**symbole R
**boitier suivant la valeur : 1206(CMS)/Axial DIN0309 (traversant)
*Condensateur
**symbole C
**boitier suivant la valeur 1206(CMS)
*VNH7070
**télécharger et décompresser le fichier [[Media:VNH7070BASTR.zip]]
**ajouter la librairie en suivante la page : https://www.snapeda.com/about/import/#KiCad6
**{{Rouge|attention}} : pour l'ajout de la librairie de l'empreinte, indique comme "pseudo nom" {{Rouge|VNH7070BASTR}}
**modèle 3d
***ajouter le fichier VNH7070BASTR.step
***faire une rotation sur X de 90°
*Arduino Nano
**symbole Arduino_Nano_v2.x
**modèle 3d
***télécharger et décompresser : [[Media:Arduino_nano.STEP.zip]]
***dans les propriétés de la carte (éditeur de pcb), onglet modèle 3d
****ajouter le fichier téléchargé
****rotation X 90
****rotation Z -90
****décalage Z 11mm
***ajouter 2 barrettes M/F
***${KICAD9_3DMODEL_DIR}/Connector_PinSocket_2.54mm.3dshapes/PinSocket_1x15_P2.54mm_Vertical.step
***décaler le 2ème en X de 15,24mm
*bornier à vis : Screw_Terminal_01x02
*MPU-9250
**mettre 2 barrettes sécables 4 contacts, espacées de 6 pas
**[[Media:SparkFun MPU-9250 Breakout.step.zip]]
*convertisseur de niveau gt1167 {{Rouge|A modifier, pas le bon écartement : 12,7mm entre les 2 barrettes M/M !!}}
**utiliser la librairie : [[Media:BOB-12009.zip]]
**modèle 3d :
***BOB-12009.step
****rotation 90/0/0
****translation 0/0/9
***ajouter 2 barrettes M/F : ${KICAD9_3DMODEL_DIR}/Connector_PinSocket_2.54mm.3dshapes/PinSocket_1x06_P2.54mm_Vertical.step
****rotation 0/0/0
****translation 5.08/6.35/0 et -5.08/6.35/0
*Autres : [[Media:SaeS2_2025.zip]]
*GroveH : [[Media:groveH.zip]]
*Connecteur à vis : [[Media:1729131.zip]]

Cours:TPS 2103 evse

2026-05-12T22:04:19Z

Bjacquot :

<accesscontrol>Acces:Prof</accesscontrol>

******************************

* modifier la partie potar pour ne faire qu'une seule lecture i2c
* revoir la partie détection voiture branchée/débranchée/en charge

******************************

=Description générale du système=

==Cadre==
[[Image:ImageEvalTpEvse.png|vignette|600px]]
Vous allez "réaliser" une '''borne de recharge''' pour voiture électrique. Nous nous plaçons dans le cas d'une recharge en courant alternatif avec un connecteur de type 2 (recharge monophasé ou triphasé).

'''La partie puissance ne nous intéresse pas''' ici et nous "alimenterons" la carte qui simule la voiture avec une tension réduite.

L'objectif est d'implémenter les étapes du '''protocole de recharge''' du côté de la borne (EVSE).

Comme vous pouvez le voir sur la figure ci-contre :
*la voiture est simulée par une carte avec des leds et un bouton (carte bleue)
*l'électronique de la borne de recharge est sur un shield arduino Nano (carte verte à gauche)
*une carte avec un mcp23008 permettra d'avoir des leds pour afficher des informations (carte noire)
*un potentiomètre est connecté sur un CAN i2c (petite carte verte à droite)

Il conviendra d'alimenter :
*la carte arduino Nano, juste en reliant le cordon usb
*le shield sur une alimentation -12v/GND/+12v : {{Rouge|attention au sens !}}

[[Image:signalControlEVSE.png|vignette|600px]]
==Fil Control Pilot==

La borne dialogue avec la voiture grâce au fil CP (cf figure ci-contre)

Il s'agira de générer un signal sur ce fil et également de lire la tension. Ceci se fait par les liaisons notées :
*'''control''' : signal généré par le µcontroleur de la carte arduino Nano
*'''mesureCP''' : signal analogique observé par la carte arduino Uno (pour rappel reliée en i2c à la carte arduino Nano)
**le signal mesureCP est identique (forme) au signal CP ci-contre
**le niveau logique bas est de l'ordre de {{Rouge|1,17V}}
**le niveau logique haut est de l'ordre de :
***{{Rouge|4,3V}} : véhicule non connecté (state A)
***{{Rouge|3,89V}} : véhicule connecté (state B)
***{{Rouge|3,47V}} : véhicule connecté (state C)
***on n'utilise pas les state D et state E

==Protocole de charge==
La gestion de la charge d'un véhicule se déroule de la façon suivante :
#'''pas de véhicule connecté''' ({{Rouge|state A}}) sur la borne (fil CP débranché) :
#*signal '''control à l'état logique 1'''
#*la valeur de mesureCP est de l'ordre de 4,3V
#'''Connection de la voiture''' borne non prête (fil CP relié):
#*signal '''control à l'état logique 1'''
#*la valeur de mesureCP est proche de 3,89V => la borne passe en mode prêt pour la charge
#'''Connection de la voiture''' ({{Rouge|state B}}) borne prête (fil CP relié):
#*signal mli à 1kHz sur le fil control (le rapport cyclique indique le courant de charge autorisé)
#*la valeur du niveau haut de mesureCP est proche de 3,89V
#*des leds sur la voiture permettent de visualiser le courant de charge autorisé
#'''Voiture prête à charger''' ({{Rouge|state C}}) (appuyer sur le bouton de la voiture):
#*signal mli à 1kHz sur le fil control (le rapport cyclique indique le courant de charge autorisé)
#*la valeur du niveau haut de mesureCP est proche de 3,47V
#*on alimente la voiture avec le fil puissance à l'état 1
#'''arrêt de la charge''' ({{Rouge|state B}}) (relâcher le bouton de la voiture):
#*signal mli à 1kHz sur le fil control (le rapport cyclique indique le courant de charge autorisé)
#*la valeur du niveau haut de mesureCP est proche de 3,89V
#*on coupe l'alimentation en passant le fil puissance à l'état 0
# '''Déconnection de la voiture''' ({{Rouge|state A}}) : arrêt de la mli
#*signal '''control à l'état logique 1'''
#*la valeur de mesureCP est proche de 4,3V

[[Fichier:ArduinoNanoPinout.png|300px|droite]]

=Exercice 1 : générer le signal MLI=

On commencera par réaliser le signal MLI qui permet d'indiquer à la voiture électrique le courant de charge autorisé.

La broche {{Rouge|PB1}} est utilisée pour le signal MLI.

Vous utiliserez le timer1 pour générer le signal MLI :
*en '''mode 14'''
*la '''fréquence de la mli''' doit être de '''1kHz'''
*le '''rapport cyclique''' sera pour le moment réglé à '''20%'''

{{Eval|4|Réaliser le programme correspondant}}

Remarque :
*visualiser la mli sur un oscilloscope avant de brancher la voiture
*vérifier ensuite que la voiture détecte bien la borne (led verte allumée)

*prendre [[Media:Atmega328p.pdf|la datasheet pages 131 et suivantes]] pour une description du Timer1
*en mode 14, la fréquence de la MLI est donnée par Fmli= Fcpu / (P * ICR1)
*rapportCyclique=OCR1A/ICR1
<source lang=cpp>
// broche en sortie

// timer1 en mode 14

// valeur du prédiviseur

// générer le signal MLI sur la broche OC1A (bits COM1xx dans le registre TCCR1A)

// valeur du rapport cyclique
</source>

= Exercice 2 : modification du courant de charge autorisé =

La valeur du rapport cyclique de la MLI permet d'indiquer à la voiture le courant maximum de charge de la façon suivante :
Current from 6A to 51A: Current [A] = Duty Cycle [%] * 0.6
Current from 51A to 80A: Current [A] = (Duty Cycle [%]-64) * 2.5

On fera varier le rapport cyclique en utilisant le potentiomètre sur la carte d'extension. Un {{Rouge|can i2c}} sur la carte permet de mesurer la tension du potentiomètre.

{{Eval|1|Trouver l'adresse du can i2c : {{Rouge|mcp3021}} }}

La datasheet du [[Media:Mcp3021.pdf|Mcp3021.pdf]] page 18 donne le principe pour faire une lecture de la valeur de conversion.

'''Attention''' :
*il n'y a pas de registres i2c dans le composant
*Il convient de faire [[Cours:InfoS2_tdI2c#Lire_sur_le_slave_:_la_target_envoie_des_donn.C3.A9es_au_controller|'''2 lectures successives''']] (sans fermer la transmission):
**on {{Rouge|"request"}} 2 octets
**lire le 1er octet => 8 bits de poids fort
**lire le 2ème octet => 8 bits de poids faible

{{Eval|4|Ecrire un programme qui permet de modifier la valeur du rapport cyclique en fonction de la valeur du potentiomètre. Les valeurs du rapport cyclique générées devront varier entre 10% (au minimum) et 60% (au maximum).}}

= Exercice 3 : détection de présence de la voiture =

La tension sur le niveau haut du signal MLI varie en fonction de :
*la présence ou non de la voiture
*si la voiture charge ou non

On mesure cette tension sur la broche ADC0 de la carte arduino Nano.

Le tableau suivant récapitule les cas possibles :
{| class="wikitable"
|-
! Etat !! Tension de l'état haut
|-
| voiture non connectée || proche de 5V
|-
| voiture connectée pas de charge || proche de 4,5V
|-
| voiture en charge || proche de 3,9V
|}

{{Eval|4|Ecrire un programme qui}}
*mesure la tension sur la broche ADC0 toutes les 200ms
*affiche sur la liaison série le message adéquat
**pas de voiture
**voiture branchée
**voiture en charge

'''Remarques''' :
*il n'est pas possible de demander une mesure de la tension du niveau logique 1 de la MLI :
*on fait la mesure en permance
**si la valeur est trop faible (tension inférieur à 3V) ne pas en tenir compte => c'est une mesure de la tension du niveau logique 0
**sinon envoyer le message selon la valeur mesurée

= Exercice 4 : Affichage sur le mcp23008=

le mcp23008 est un GPIO expander avec 8 gpio. Le principe d'utilisation est identique au mcp23017.

Vous utiliserez [[Media:Mcp23008.pdf| la datasheet du composant]] pour écrire votre programme, ainsi que la déclaration des registres :

<source lang=cpp>
#define IODIR 0x00
#define IPOL 0x01
#define GPINTEN 0x02
#define DEFVAL 0x03
#define INTCON 0x04
#define IOCON 0x05
#define GPPU 0x06
#define INTF 0x07
#define INTCAP 0x08
#define GPIO 0x09
#define OLAT 0x0A
</source>

{{Eval|4|Utiliser 3 leds du mcp23008 :}}
*la led de la gpio7 s'allume lorsqu'il n'y a pas de voiture
*la led de la gpio6 s'allume lorsqu'une voiture est branchée mais qu'elle ne charge pas
*la led de la gpio5 s'allume lorsqu'une voiture est branchée et en charge

= Exercice 5 : Mise en place du protocole de charge=

{{Eval|3|Implanter le protocole complet en gérant l'alimentation de la voiture avec le signal puissance}}

*la broche {{Rouge|PC2 est utilisée pour alimenter la voiture}}

=documentation=
*[[Media:Atmega328p.pdf|datasheet atmega328p]]
*[[Media:Current-State-of-the-Art-EV-Chargers.pdf|https://www.hnei.hawaii.edu/wp-content/uploads/Current-State-of-the-Art-EV-Chargers.pdf]]

Cours:TPS 2103 evse

2026-05-12T14:10:39Z

Bjacquot : /* Exercice 3 : détection de présence de la voiture */

<accesscontrol>Acces:Prof</accesscontrol>

=Description générale du système=

==Cadre==
[[Image:ImageEvalTpEvse.png|vignette|600px]]
Vous allez "réaliser" une '''borne de recharge''' pour voiture électrique. Nous nous plaçons dans le cas d'une recharge en courant alternatif avec un connecteur de type 2 (recharge monophasé ou triphasé).

'''La partie puissance ne nous intéresse pas''' ici et nous "alimenterons" la carte qui simule la voiture avec une tension réduite.

L'objectif est d'implémenter les étapes du '''protocole de recharge''' du côté de la borne (EVSE).

Comme vous pouvez le voir sur la figure ci-contre :
*la voiture est simulée par une carte avec des leds et un bouton (carte bleue)
*l'électronique de la borne de recharge est sur un shield arduino Nano (carte verte à gauche)
*une carte avec un mcp23008 permettra d'avoir des leds pour afficher des informations (carte noire)
*un potentiomètre est connecté sur un CAN i2c (petite carte verte à droite)

Il conviendra d'alimenter :
*la carte arduino Nano, juste en reliant le cordon usb
*le shield sur une alimentation -12v/GND/+12v : {{Rouge|attention au sens !}}

[[Image:signalControlEVSE.png|vignette|600px]]
==Fil Control Pilot==

La borne dialogue avec la voiture grâce au fil CP (cf figure ci-contre)

Il s'agira de générer un signal sur ce fil et également de lire la tension. Ceci se fait par les liaisons notées :
*'''control''' : signal généré par le µcontroleur de la carte arduino Nano
*'''mesureCP''' : signal analogique observé par la carte arduino Uno (pour rappel reliée en i2c à la carte arduino Nano)
**le signal mesureCP est identique (forme) au signal CP ci-contre
**le niveau logique bas est de l'ordre de {{Rouge|1,17V}}
**le niveau logique haut est de l'ordre de :
***{{Rouge|4,3V}} : véhicule non connecté (state A)
***{{Rouge|3,89V}} : véhicule connecté (state B)
***{{Rouge|3,47V}} : véhicule connecté (state C)
***on n'utilise pas les state D et state E

==Protocole de charge==
La gestion de la charge d'un véhicule se déroule de la façon suivante :
#'''pas de véhicule connecté''' ({{Rouge|state A}}) sur la borne (fil CP débranché) :
#*signal '''control à l'état logique 1'''
#*la valeur de mesureCP est de l'ordre de 4,3V
#'''Connection de la voiture''' borne non prête (fil CP relié):
#*signal '''control à l'état logique 1'''
#*la valeur de mesureCP est proche de 3,89V => la borne passe en mode prêt pour la charge
#'''Connection de la voiture''' ({{Rouge|state B}}) borne prête (fil CP relié):
#*signal mli à 1kHz sur le fil control (le rapport cyclique indique le courant de charge autorisé)
#*la valeur du niveau haut de mesureCP est proche de 3,89V
#*des leds sur la voiture permettent de visualiser le courant de charge autorisé
#'''Voiture prête à charger''' ({{Rouge|state C}}) (appuyer sur le bouton de la voiture):
#*signal mli à 1kHz sur le fil control (le rapport cyclique indique le courant de charge autorisé)
#*la valeur du niveau haut de mesureCP est proche de 3,47V
#*on alimente la voiture avec le fil puissance à l'état 1
#'''arrêt de la charge''' ({{Rouge|state B}}) (relâcher le bouton de la voiture):
#*signal mli à 1kHz sur le fil control (le rapport cyclique indique le courant de charge autorisé)
#*la valeur du niveau haut de mesureCP est proche de 3,89V
#*on coupe l'alimentation en passant le fil puissance à l'état 0
# '''Déconnection de la voiture''' ({{Rouge|state A}}) : arrêt de la mli
#*signal '''control à l'état logique 1'''
#*la valeur de mesureCP est proche de 4,3V

[[Fichier:ArduinoNanoPinout.png|300px|droite]]

=Exercice 1 : générer le signal MLI=

On commencera par réaliser le signal MLI qui permet d'indiquer à la voiture électrique le courant de charge autorisé.

La broche {{Rouge|PB1}} est utilisée pour le signal MLI.

Vous utiliserez le timer1 pour générer le signal MLI :
*en '''mode 14'''
*la '''fréquence de la mli''' doit être de '''1kHz'''
*le '''rapport cyclique''' sera pour le moment réglé à '''20%'''

{{Eval|4|Réaliser le programme correspondant}}

Remarque :
*visualiser la mli sur un oscilloscope avant de brancher la voiture
*vérifier ensuite que la voiture détecte bien la borne (led verte allumée)

*prendre [[Media:Atmega328p.pdf|la datasheet pages 131 et suivantes]] pour une description du Timer1
*en mode 14, la fréquence de la MLI est donnée par Fmli= Fcpu / (P * ICR1)
*rapportCyclique=OCR1A/ICR1
<source lang=cpp>
// broche en sortie

// timer1 en mode 14

// valeur du prédiviseur

// générer le signal MLI sur la broche OC1A (bits COM1xx dans le registre TCCR1A)

// valeur du rapport cyclique
</source>

= Exercice 2 : modification du courant de charge autorisé =

La valeur du rapport cyclique de la MLI permet d'indiquer à la voiture le courant maximum de charge de la façon suivante :
Current from 6A to 51A: Current [A] = Duty Cycle [%] * 0.6
Current from 51A to 80A: Current [A] = (Duty Cycle [%]-64) * 2.5

On fera varier le rapport cyclique en utilisant le potentiomètre sur la carte d'extension. Un {{Rouge|can i2c}} sur la carte permet de mesurer la tension du potentiomètre.

{{Eval|1|Trouver l'adresse du can i2c : {{Rouge|mcp3021}} }}

La datasheet du [[Media:Mcp3021.pdf|Mcp3021.pdf]] page 18 donne le principe pour faire une lecture de la valeur de conversion.

'''Attention''' :
*il n'y a pas de registres i2c dans le composant
*Il convient de faire [[Cours:InfoS2_tdI2c#Lire_sur_le_slave_:_la_target_envoie_des_donn.C3.A9es_au_controller|'''2 lectures successives''']] (sans fermer la transmission):
**on {{Rouge|"request"}} 2 octets
**lire le 1er octet => 8 bits de poids fort
**lire le 2ème octet => 8 bits de poids faible

{{Eval|4|Ecrire un programme qui permet de modifier la valeur du rapport cyclique en fonction de la valeur du potentiomètre. Les valeurs du rapport cyclique générées devront varier entre 10% (au minimum) et 60% (au maximum).}}

= Exercice 3 : détection de présence de la voiture =

La tension sur le niveau haut du signal MLI varie en fonction de :
*la présence ou non de la voiture
*si la voiture charge ou non

On mesure cette tension sur la broche ADC0 de la carte arduino Nano.

Le tableau suivant récapitule les cas possibles :
{| class="wikitable"
|-
! Etat !! Tension de l'état haut
|-
| voiture non connectée || proche de 5V
|-
| voiture connectée pas de charge || proche de 4,5V
|-
| voiture en charge || proche de 3,9V
|}

{{Eval|4|Ecrire un programme qui}}
*mesure la tension sur la broche ADC0 toutes les 200ms
*affiche sur la liaison série le message adéquat
**pas de voiture
**voiture branchée
**voiture en charge

'''Remarques''' :
*il n'est pas possible de demander une mesure de la tension du niveau logique 1 de la MLI :
*on fait la mesure en permance
**si la valeur est trop faible (tension inférieur à 3V) ne pas en tenir compte => c'est une mesure de la tension du niveau logique 0
**sinon envoyer le message selon la valeur mesurée

= Exercice 4 : Affichage sur le mcp23008=

le mcp23008 est un GPIO expander avec 8 gpio. Le principe d'utilisation est identique au mcp23017.

Vous utiliserez [[Media:Mcp23008.pdf| la datasheet du composant]] pour écrire votre programme, ainsi que la déclaration des registres :

<source lang=cpp>
#define IODIR 0x00
#define IPOL 0x01
#define GPINTEN 0x02
#define DEFVAL 0x03
#define INTCON 0x04
#define IOCON 0x05
#define GPPU 0x06
#define INTF 0x07
#define INTCAP 0x08
#define GPIO 0x09
#define OLAT 0x0A
</source>

{{Eval|4|Utiliser 3 leds du mcp23008 :}}
*la led de la gpio7 s'allume lorsqu'il n'y a pas de voiture
*la led de la gpio6 s'allume lorsqu'une voiture est branchée mais qu'elle ne charge pas
*la led de la gpio5 s'allume lorsqu'une voiture est branchée et en charge

= Exercice 5 : Mise en place du protocole de charge=

{{Eval|3|Implanter le protocole complet en gérant l'alimentation de la voiture avec le signal puissance}}

*la broche {{Rouge|PC2 est utilisée pour alimenter la voiture}}

=documentation=
*[[Media:Atmega328p.pdf|datasheet atmega328p]]
*[[Media:Current-State-of-the-Art-EV-Chargers.pdf|https://www.hnei.hawaii.edu/wp-content/uploads/Current-State-of-the-Art-EV-Chargers.pdf]]

Cours:SaeRobotiqueSuiviLigne

2026-05-11T14:08:57Z

Bjacquot : /* Séquence 2 : tâches complexes individuelles + réalisation shield */

=Utiliser des librairies arduino avec un main =

[[Cours:ArduinoSansLoopSetup|Arduino sans loop/setup]]

Un certain nombre de librairies utilisent les fontions arduino [https://github.com/arduino/ArduinoCore-avr/blob/master/cores/arduino/wiring.c delay/delayMicroseconds/millis/micros]

Ces fonctions utilisent le Timer0 et en particulier l'interruption de débordement.

Ce Timer est configuré dans la fonction [https://github.com/arduino/ArduinoCore-avr/blob/master/cores/arduino/wiring.c init()], qui est appelée dans le [https://github.com/arduino/ArduinoCore-avr/blob/master/cores/arduino/main.cpp "main arduino"]

{|
|-
|
On peut donc initialiser ce Timer0 pour qu'il génère un débordement tel qu'attendu.

Ainsi les fonctions de gestion du temps Arduino peuvent fonctionner comme prévu et on peut ainsi utiliser les librairies qui en dépendent :

<source lang=cpp>
void initFonctionsTempsArduino()
{
sei();
// marche pour 328p et 2560 et autres ...
// à adapter suivant le µc
// cf https://github.com/arduino/ArduinoCore-avr/blob/master/cores/arduino/wiring.c
TCCR0A=(1<<WGM01)|(1<<WGM00);
TCCR0B=(1<<CS01)|(1<<CS00);
TIMSK0=(1<<TOIE0);
}

int main()
{
initFonctionsTempsArduino();
Serial.begin(115200);
while(1)
{
delay(100);
Serial.println(millis());
}
}
</source>

||
<source lang=cpp>
/*
Exemple pour le capteur vl53l1x :
cf exemple de la librairie pour des commentaires
*/
#include <Wire.h>
#include <VL53L1X.h>
VL53L1X sensor;

void initFonctionsTempsArduino()
{
sei();
// marche pour 328p et 2560 et autres ...
// à adapter suivant le µc
// cf https://github.com/arduino/ArduinoCore-avr/blob/master/cores/arduino/wiring.c
TCCR0A=(1<<WGM01)|(1<<WGM00);
TCCR0B=(1<<CS01)|(1<<CS00);
TIMSK0=(1<<TOIE0);
}

int main()
{
initFonctionsTempsArduino();
while (!Serial) {}
Serial.begin(115200);
Wire.begin();
Wire.setClock(400000); // use 400 kHz I2C
sensor.setTimeout(500);
if (!sensor.init())
{
Serial.println("Failed to detect and initialize sensor!");
while (1);
}
sensor.setDistanceMode(VL53L1X::Long);
sensor.setMeasurementTimingBudget(50000);
sensor.startContinuous(50);
while(1)
{
Serial.print(sensor.read());
if (sensor.timeoutOccurred()) { Serial.print(" TIMEOUT"); }
Serial.println();
}
}
</source>
|}

=Augmenter la rapidité des Lidars=
<source lang=cpp>
sensors[i].setMeasurementTimingBudget(20000);
sensors[i].setDistanceMode(VL53L1X::Short);
sensors[i].startContinuous(20);
sensors[0].read(false);
</source>

= Séquence 1 : tâches élémentaires individuelles =

* Tâches de suivi de ligne (un étudiant sur chaque tâche) :
** suivi de cap avec MPU9250
** suivi avec capteurs photorélectifs (nombre de capteurs à choisir)
** suivi avec Lidar, en suivant un mur sur le côté

* s'arrêter à la fin du parcours

* À faire globalement : câblage robot, sécurité

==Livrable 1==
* faire des recherches pour rendre un dossier par groupe (pour lundi 27/05) expliquant : le pont en H, schéma sécurité et chaque partie (a, b, c)
* évaluation le 24/05 (code + questions + fonctionnement)

= Séquence 2 : tâches complexes individuelles + réalisation shield =

* Tâches de suivi (à modifier)
** Capteurs photoréflectifs : détection de marques à droite (si marque : on tourne à droite à l'intersection, sinon tout droit). Détection des marques à gauche : stop et recul pendant 1 seconde (environ) et on repart (pas d'arrêt sur le second passage)
** Lidar : suivi de mur à gauche ET à droite (priorité en suivi à droite). Faire tomber une première barre, pas la seconde.

* Trois cartes à réaliser (une par étudiant)
** carte avec capteurs photoreflectifs
** carte drivers moteur
** carte shield arduino nano

==Livrable 2==

* évaluation le 02/06 (routage/fabrication)

= Séquence 3 : Fusion des trois tâches et programmation globale=

==Livrable 3 ==

= Rapport final =

* Rapport final :
** '''À envoyer au format pdf par mail avant le DD/MM/YY à HH'''
** Diagramme de Gantt
** diagramme algorithme général
** stratégie de résolution de chaque tâche
** Mini-concours à la fin pour sélectionner le meilleur robot (évaluation des capacités du robot, par étudiant en fonction de l'organisation prévue).
** Chiffrage incluant le matériel ainsi que les ressources humaines.

=Organisation=

*Fonctionnement en trinôme sur 12 jours
**9h-12h
**13h30-16h30
*{{Rouge|Compte rendu écrit quotidien individuel}}
**sera contrôlé chaque matin
**doit indiquer les tâches réalisées la veille
**doit indiquer le travail à réaliser le jour même

=Ressources=

==Composants/cartes==
*[[Cours:capteurPhotoReflectif|capteur '''photoréflectif''' pour détection de la {{Rouge|ligne}}]]
*convertisseur de niveau:
**https://www.eeweb.com/level-shifting-techniques-in-i2c-bus-design/
*Batterie LiFePo4
**assemblage de 4 éléments LiFePo4
**documentation sur les cellules [[Media:CellulesLiFePo4.pdf]]
**tensions à ne pas dépasser :
***maximum : 3,45V/élément
***minimum : 2,65V/élément
***ne pas démarrer le robot : 2,85V/élément
*divers
**Commutateur d'arrêt d'urgence https://fr.farnell.com/idec/yw1b-v4e01r/commut-bp-e-stop-spst-nc-10a-120v/dp/2833849?ost=2833849
**Régulateur ajustable 1,25 à 30 Vcc https://www.gotronic.fr/art-regulateur-ajustable-1-25-a-30-vcc-gt134-26094.htm
*driver de moteur
**https://www.cytron.io/p-13amp-6v-30v-dc-motor-driver
*capteurs de distance/contact
**HC-SR04 cf fiche technique sur la page : https://www.gotronic.fr/art-module-de-detection-us-hc-sr04-20912.htm
**VL53L1X
***https://www.robotshop.com/eu/fr/platine-deploiement-capteur-distance-tof-regulateur-tension-vl53l1x.html
***https://github.com/pololu/vl53l1x-arduino
**Mini Microrupteur - SPDT https://www.robotshop.com/eu/fr/mini-microrupteur-spdt-levier-rouleau.html
**GP2Yxxxx https://www.gotronic.fr/art-capteur-de-mesure-sharp-gp2y0a41sk0f-18338.htm
**lidar tfmini-s
***https://www.robotshop.com/eu/fr/module-micro-lidar-tfmini-s-benewake-i2c-12m.html
***https://www.arduino.cc/reference/en/libraries/tfmpi2c/
**lidar Lite 3
***https://www.robotshop.com/eu/fr/capteur-distance-laser-haute-performance-lidar-lite-3-llv3hp.html
***https://github.com/RobotShop/LIDARLite_v3_Arduino_Library
*caméra
**pixyv2
***https://pixycam.com/pixy2/
***[[Cours:TPS_2103_tp_pixy|TP caméra pixy]]
***Avoir un PixyMon plus rapide dans la g.008 :
****utiliser un 2ème poste
****ne pas se connecter sur nomachine
****lancer un terminal
****lancer la commande PixyMon
*IMU
**Explications du principe du capteur mpu9250 : https://learn.sparkfun.com/tutorials/mpu-9250-hookup-guide/all
**Bibliothèque à utiliser : dans le gestionnaire de bibliothèque => ''by hideakitai'' (v 0.4.8) ou https://github.com/hideakitai/MPU9250
**Étapes :
***Réaliser la calibration et noter les valeurs affichées,
***les entrer dans votre programme (fonctions setMagBias() et setMagScale()
***Pour réaliser une mesure, se servir des programmes d'exemples
*Robot Arrex :
** [[Cours:RobotArrex]] (section documents)
** avec shield moteur

==Fichiers/Images==

*[[Image:CircuitBUT2.png|250px]]

==liens (dont règlement concours) ==
* concours robotique Cachan, lien vers le règlement en pdf : https://www.festivalrobotiquecachan.fr/wp-content/uploads/Reglement_rencontres_de_robotique_GEII_BUT-1-2-3.pdf
* [[Media:FRC2024-Guideparticipant-v1.01.pdf|Organisation du concours]]
*[[Cours:archive SAÉ robot joueur de tennis]]
*[[Cours:archive SAÉ suivi de ligne]]
*https://www.youtube.com/watch?v=xH8EIqh-2_Y

Cours:PiPico

2026-04-09T08:48:47Z

Bjacquot : /* configuration cmake */

= Brochage =

https://datasheets.raspberrypi.com/pico/Pico-R3-A4-Pinout.pdf

=utilisation de l'ide arduino=

https://github.com/earlephilhower/arduino-pico

=non recommandé : QtCreator=

== Création assistée d'un projet ==

À l'aide de ''pico_project.py'' :
* ''git clone https://github.com/raspberrypi/pico-project-generator.git''
* ''./pico_project.py --gui''
* ne pas cocher "create VSCode project"

Attention, ne pas oublier de spécifier le chemin vers le SDK :
* ''export PICO_SDK_PATH=../../pico-sdk'' en remplaçant ''../../pico-sdk'' par le chemin vers le SDK.

== Ouverture avec QTCreator ==

QtCreator est capable de lire et interpréter le fichier ''CMakeLists.txt'' comme descripteur de projet, il suffit donc
* d'ouvrir (comme projet) le fichier ''CMakeLists.txt''

=VsCode=

*installer VsCode
**https://doc.ubuntu-fr.org/visual_studio_code
*ajouter le plugin pi pico
**https://github.com/raspberrypi/pico-vscode
**https://datasheets.raspberrypi.com/pico/getting-started-with-pico.pdf

=Registres=

==gpio==
<source lang=cpp>
#include "pico/stdlib.h"
#include "hardware/regs/addressmap.h"

unsigned int& gpioOUT = *(unsigned int*) (SIO_BASE + 0x10);
unsigned int& gpioOE = *(unsigned int*) (SIO_BASE + 0x20);

unsigned int& gpioCtrl0 = *(unsigned int *) (IO_BANK0_BASE+0x4);
//facultatif
unsigned int& padsBank0_GPIO0 = *(unsigned int *) (PADS_BANK0_BASE+0x4);

int main() {
// facultatif
padsBank0_GPIO0|=(1<<6); // input enable
padsBank0_GPIO0&=~(1<<7); // output disable
// piloter la broche avec fonction SIO
gpioCtrl0=5;
// sortie enable
gpioOE=1<<0;
while (true)
{
gpioOUT&=~(1<<0);
sleep_ms(200);
gpioOUT|=(1<<0);
sleep_ms(10);
}
}
</source>

=usage des périphériques au travers du sdk=

== Référence en PDF du Pico C++ SDK ==

[https://pip-assets.raspberrypi.com/categories/609-microcontroller-boards/documents/RP-009085-KB-1-raspberry-pi-pico-c-sdk.pdf Raspberry Pi Pico-series C/C++ SDK Libraries and tools for C/C++ development on Raspberry Pi microcontrollers]

==GPIO==

https://www.raspberrypi.com/documentation/pico-sdk/hardware.html#hardware_gpio

==IO==

{| class="wikitable"
|-
! Syntaxe
||void gpio_init(uint gpio)
|-
! Paramètres
||
{| class="wikitable"
|-
| gpio || numéro de gpio
|}
|}
*gpio_put(LED_PIN, 1);
*gpio_set_dir(LED_PIN, GPIO_OUT);
*gpio_set_pulls (uint gpio, bool up, bool down)

==interrupt==

Il n'y a pas d'interruption dédiée à une broche particulière. Toutes les gpio déclenchent la même interruption. Il convient ensuite de regarder lesquelles ont déclenchées l'interruption :

<source lang=cpp>

void my_raw_interrupt_handler()
{
const int32_t gpio;
if (gpio_get_irq_event_mask(gpio) & (GPIO_IRQ_EDGE_RISE|GPIO_IRQ_EDGE_FALL))
{
if (gpio_get_irq_event_mask(gpio) & (GPIO_IRQ_EDGE_RISE)) // Front Montant
{

}
else
{
}
gpio_acknowledge_irq(gpio, GPIO_IRQ_EDGE_RISE|GPIO_IRQ_EDGE_FALL);
}
}

...
gpio_set_irq_enabled(2, GPIO_IRQ_EDGE_FALL | GPIO_IRQ_EDGE_RISE, true);
...
</source>

==Pwm==

https://raspberry-pi.developpez.com/actu/344283/Raspberry-Pi-Pico-moins-Apprendre-a-generer-des-signaux-PWM-un-billet-blog-de-f-leb/

Fmli = Fcpu / ( wrap * clkdiv ) // sur pi pico, Fcpu=125MHz

*clkdiv:
**Le registre qui stocke le diviseur de fréquence comprend 8 bits pour la partie entière, et 4 bits pour la partie fractionnaire
**valeur max de clkdiv : 255 + 15/16
**ex : pwm_set_clkdiv_int_frac (slice, 38, 3); // diviseur de fréquence = 38 + 3/16

*gpio_set_function(PICO_DEFAULT_LED_PIN, GPIO_FUNC_PWM);
*uint slice_num = pwm_gpio_to_slice_num(PICO_DEFAULT_LED_PIN);
*pwm_config config = pwm_get_default_config();
*pwm_config_set_clkdiv(&config, 4.f);
*pwm_init(slice_num, &config, true);
*pwm_set_gpio_level(PICO_DEFAULT_LED_PIN, fade * fade); // rapport cyclique 16 bits

==I2C==

===configuration cmake===
dans le fichier CMakeLists.txt ajouter dans la liste target_link_libraries
<source lang=cpp>
target_link_libraries(
....
hardware_i2c
....
)
</source>

===i2c scanner===

<source lang=cpp>
#include <stdio.h>
#include "pico/stdlib.h"
#include "hardware/i2c.h"
#include "hardware/timer.h"
#include "hardware/clocks.h"
#include "pico/binary_info.h"

int64_t alarm_callback(alarm_id_t id, void *user_data) {
// Put your timeout handler code in here
return 0;
}

bool reserved_addr(uint8_t addr) {
return (addr & 0x78) == 0 || (addr & 0x78) == 0x78;
}
int main()
{
stdio_init_all();

// I2C Initialisation. Using it at 400Khz.
i2c_init(i2c0, 100*1000);

gpio_set_function(PICO_DEFAULT_I2C_SDA_PIN, GPIO_FUNC_I2C);
gpio_set_function(PICO_DEFAULT_I2C_SCL_PIN, GPIO_FUNC_I2C);
gpio_pull_up(PICO_DEFAULT_I2C_SDA_PIN);
gpio_pull_up(PICO_DEFAULT_I2C_SCL_PIN);
// For more examples of I2C use see https://github.com/raspberrypi/pico-examples/tree/master/i2c
bi_decl(bi_2pins_with_func(PICO_DEFAULT_I2C_SDA_PIN, PICO_DEFAULT_I2C_SCL_PIN, GPIO_FUNC_I2C));

// Timer example code - This example fires off the callback after 2000ms
add_alarm_in_ms(2000, alarm_callback, NULL, false);
// For more examples of timer use see https://github.com/raspberrypi/pico-examples/tree/master/timer

printf("System Clock Frequency is %d Hz\n", clock_get_hz(clk_sys));
printf("USB Clock Frequency is %d Hz\n", clock_get_hz(clk_usb));
// For more examples of clocks use see https://github.com/raspberrypi/pico-examples/tree/master/clocks

while (true) {
printf("\nI2C Bus Scan\n");
printf(" 0 1 2 3 4 5 6 7 8 9 A B C D E F\n");

for (int addr = 0; addr < (1 << 7); ++addr) {
if (addr % 16 == 0) {
printf("%02x ", addr);
}

// Perform a 1-byte dummy read from the probe address. If a slave
// acknowledges this address, the function returns the number of bytes
// transferred. If the address byte is ignored, the function returns
// -1.

// Skip over any reserved addresses.
int ret;
uint8_t rxdata;
if (reserved_addr(addr))
ret = PICO_ERROR_GENERIC;
else
ret = i2c_read_blocking(i2c_default, addr, &rxdata, 1, false);

printf(ret < 0 ? "." : "@");
printf(addr % 16 == 15 ? "\n" : " ");
}
printf("Done.\n");

sleep_ms(1000);
}
}

</source>

===read/write register===

<source lang=cpp>
void writeI2cReg(uint8_t targetAddress, uint8_t regAddress, uint8_t regValue)
{
uint8_t data[2]={regAddress,regValue};
i2c_write_blocking(i2c0,targetAddress,data,2,false);
}

uint8_t readI2cReg(uint8_t targetAddress, uint8_t regAddress)
{
i2c_write_blocking(i2c0,targetAddress,&regAddress,1,true);
uint8_t regValue;
i2c_read_blocking(i2c0,targetAddress,&regValue,1,false);
return regValue;
}
</source>

==adc==

==uart==
*https://www.raspberrypi.com/documentation/pico-sdk/hardware.html#group_hardware_uart

==pio==

===ws2812===
https://github.com/ForsakenNGS/PicoLED

=liens=
*https://www.gibbard.me/using_the_raspberry_pi_pico_on_ubuntu/
*https://tutoduino.fr/en/pico-platformio/
*visual studio code :
**https://datasheets.raspberrypi.com/pico/getting-started-with-pico.pdf partie 7.1
**https://www.electronicshub.org/program-raspberry-pi-pico-with-visual-studio-code/
*https://github.com/raspberrypi/picotool

Cours:PiPico

2026-04-09T08:16:12Z

Bjacquot : /* I2C */

= Brochage =

https://datasheets.raspberrypi.com/pico/Pico-R3-A4-Pinout.pdf

=utilisation de l'ide arduino=

https://github.com/earlephilhower/arduino-pico

=non recommandé : QtCreator=

== Création assistée d'un projet ==

À l'aide de ''pico_project.py'' :
* ''git clone https://github.com/raspberrypi/pico-project-generator.git''
* ''./pico_project.py --gui''
* ne pas cocher "create VSCode project"

Attention, ne pas oublier de spécifier le chemin vers le SDK :
* ''export PICO_SDK_PATH=../../pico-sdk'' en remplaçant ''../../pico-sdk'' par le chemin vers le SDK.

== Ouverture avec QTCreator ==

QtCreator est capable de lire et interpréter le fichier ''CMakeLists.txt'' comme descripteur de projet, il suffit donc
* d'ouvrir (comme projet) le fichier ''CMakeLists.txt''

=VsCode=

*installer VsCode
**https://doc.ubuntu-fr.org/visual_studio_code
*ajouter le plugin pi pico
**https://github.com/raspberrypi/pico-vscode
**https://datasheets.raspberrypi.com/pico/getting-started-with-pico.pdf

=Registres=

==gpio==
<source lang=cpp>
#include "pico/stdlib.h"
#include "hardware/regs/addressmap.h"

unsigned int& gpioOUT = *(unsigned int*) (SIO_BASE + 0x10);
unsigned int& gpioOE = *(unsigned int*) (SIO_BASE + 0x20);

unsigned int& gpioCtrl0 = *(unsigned int *) (IO_BANK0_BASE+0x4);
//facultatif
unsigned int& padsBank0_GPIO0 = *(unsigned int *) (PADS_BANK0_BASE+0x4);

int main() {
// facultatif
padsBank0_GPIO0|=(1<<6); // input enable
padsBank0_GPIO0&=~(1<<7); // output disable
// piloter la broche avec fonction SIO
gpioCtrl0=5;
// sortie enable
gpioOE=1<<0;
while (true)
{
gpioOUT&=~(1<<0);
sleep_ms(200);
gpioOUT|=(1<<0);
sleep_ms(10);
}
}
</source>

=usage des périphériques au travers du sdk=

== Pico C++ SDK ==

Raspberry Pi Pico-series C/C++ SDK
Libraries and tools for C/C++ development on Raspberry Pi
microcontrollers :
https://pip-assets.raspberrypi.com/categories/609-microcontroller-boards/documents/RP-009085-KB-1-raspberry-pi-pico-c-sdk.pdf

==GPIO==

https://www.raspberrypi.com/documentation/pico-sdk/hardware.html#hardware_gpio

==IO==

{| class="wikitable"
|-
! Syntaxe
||void gpio_init(uint gpio)
|-
! Paramètres
||
{| class="wikitable"
|-
| gpio || numéro de gpio
|}
|}
*gpio_put(LED_PIN, 1);
*gpio_set_dir(LED_PIN, GPIO_OUT);
*gpio_set_pulls (uint gpio, bool up, bool down)

==interrupt==

Il n'y a pas d'interruption dédiée à une broche particulière. Toutes les gpio déclenchent la même interruption. Il convient ensuite de regarder lesquelles ont déclenchées l'interruption :

<source lang=cpp>

void my_raw_interrupt_handler()
{
const int32_t gpio;
if (gpio_get_irq_event_mask(gpio) & (GPIO_IRQ_EDGE_RISE|GPIO_IRQ_EDGE_FALL))
{
if (gpio_get_irq_event_mask(gpio) & (GPIO_IRQ_EDGE_RISE)) // Front Montant
{

}
else
{
}
gpio_acknowledge_irq(gpio, GPIO_IRQ_EDGE_RISE|GPIO_IRQ_EDGE_FALL);
}
}

...
gpio_set_irq_enabled(2, GPIO_IRQ_EDGE_FALL | GPIO_IRQ_EDGE_RISE, true);
...
</source>

==Pwm==

https://raspberry-pi.developpez.com/actu/344283/Raspberry-Pi-Pico-moins-Apprendre-a-generer-des-signaux-PWM-un-billet-blog-de-f-leb/

Fmli = Fcpu / ( wrap * clkdiv ) // sur pi pico, Fcpu=125MHz

*clkdiv:
**Le registre qui stocke le diviseur de fréquence comprend 8 bits pour la partie entière, et 4 bits pour la partie fractionnaire
**valeur max de clkdiv : 255 + 15/16
**ex : pwm_set_clkdiv_int_frac (slice, 38, 3); // diviseur de fréquence = 38 + 3/16

*gpio_set_function(PICO_DEFAULT_LED_PIN, GPIO_FUNC_PWM);
*uint slice_num = pwm_gpio_to_slice_num(PICO_DEFAULT_LED_PIN);
*pwm_config config = pwm_get_default_config();
*pwm_config_set_clkdiv(&config, 4.f);
*pwm_init(slice_num, &config, true);
*pwm_set_gpio_level(PICO_DEFAULT_LED_PIN, fade * fade); // rapport cyclique 16 bits

==I2C==

==configuration cmake==
ajouter dans la liste target_link_libraries
<source lang=cpp>
target_link_libraries(
....
hardware_i2c
....
)
</source>

===i2c scanner===

<source lang=cpp>
#include <stdio.h>
#include "pico/stdlib.h"
#include "hardware/i2c.h"
#include "hardware/timer.h"
#include "hardware/clocks.h"
#include "pico/binary_info.h"

int64_t alarm_callback(alarm_id_t id, void *user_data) {
// Put your timeout handler code in here
return 0;
}

bool reserved_addr(uint8_t addr) {
return (addr & 0x78) == 0 || (addr & 0x78) == 0x78;
}
int main()
{
stdio_init_all();

// I2C Initialisation. Using it at 400Khz.
i2c_init(i2c0, 100*1000);

gpio_set_function(PICO_DEFAULT_I2C_SDA_PIN, GPIO_FUNC_I2C);
gpio_set_function(PICO_DEFAULT_I2C_SCL_PIN, GPIO_FUNC_I2C);
gpio_pull_up(PICO_DEFAULT_I2C_SDA_PIN);
gpio_pull_up(PICO_DEFAULT_I2C_SCL_PIN);
// For more examples of I2C use see https://github.com/raspberrypi/pico-examples/tree/master/i2c
bi_decl(bi_2pins_with_func(PICO_DEFAULT_I2C_SDA_PIN, PICO_DEFAULT_I2C_SCL_PIN, GPIO_FUNC_I2C));

// Timer example code - This example fires off the callback after 2000ms
add_alarm_in_ms(2000, alarm_callback, NULL, false);
// For more examples of timer use see https://github.com/raspberrypi/pico-examples/tree/master/timer

printf("System Clock Frequency is %d Hz\n", clock_get_hz(clk_sys));
printf("USB Clock Frequency is %d Hz\n", clock_get_hz(clk_usb));
// For more examples of clocks use see https://github.com/raspberrypi/pico-examples/tree/master/clocks

while (true) {
printf("\nI2C Bus Scan\n");
printf(" 0 1 2 3 4 5 6 7 8 9 A B C D E F\n");

for (int addr = 0; addr < (1 << 7); ++addr) {
if (addr % 16 == 0) {
printf("%02x ", addr);
}

// Perform a 1-byte dummy read from the probe address. If a slave
// acknowledges this address, the function returns the number of bytes
// transferred. If the address byte is ignored, the function returns
// -1.

// Skip over any reserved addresses.
int ret;
uint8_t rxdata;
if (reserved_addr(addr))
ret = PICO_ERROR_GENERIC;
else
ret = i2c_read_blocking(i2c_default, addr, &rxdata, 1, false);

printf(ret < 0 ? "." : "@");
printf(addr % 16 == 15 ? "\n" : " ");
}
printf("Done.\n");

sleep_ms(1000);
}
}

</source>

===read/write register===

<source lang=cpp>
void writeI2cReg(uint8_t targetAddress, uint8_t regAddress, uint8_t regValue)
{
uint8_t data[2]={regAddress,regValue};
i2c_write_blocking(i2c0,targetAddress,data,2,false);
}

uint8_t readI2cReg(uint8_t targetAddress, uint8_t regAddress)
{
i2c_write_blocking(i2c0,targetAddress,&regAddress,1,true);
uint8_t regValue;
i2c_read_blocking(i2c0,targetAddress,&regValue,1,false);
return regValue;
}
</source>

==adc==

==uart==
*https://www.raspberrypi.com/documentation/pico-sdk/hardware.html#group_hardware_uart

==pio==

===ws2812===
https://github.com/ForsakenNGS/PicoLED

=liens=
*https://www.gibbard.me/using_the_raspberry_pi_pico_on_ubuntu/
*https://tutoduino.fr/en/pico-platformio/
*visual studio code :
**https://datasheets.raspberrypi.com/pico/getting-started-with-pico.pdf partie 7.1
**https://www.electronicshub.org/program-raspberry-pi-pico-with-visual-studio-code/
*https://github.com/raspberrypi/picotool

Cours:SaeEvitementObstacles

2026-04-07T15:10:28Z

Bjacquot :

https://docs.google.com/document/d/1lLrXOisqDBmTie8lAPcVor_al1TS7HhtI7Or8wFLcsg/edit?tab=t.0

support de présentation :
https://docs.google.com/presentation/d/1r9tSETGUbYgtk2Ip78lNhEWxcHYtDbIx4epwVoeI2hs/edit?slide=id.p#slide=id.p

fonctions :
https://docs.google.com/spreadsheets/d/1GX3zPpdC4umtqc4B8hLjQZWTMNHfw7GfKqrpxW5ORzc/edit?usp=sharing

https://www.festivalrobotiquecachan.fr/

https://www.festivalrobotiquecachan.fr/wp-content/uploads/Reglement_rencontres_de_robotique_GEII_BUT-1-2-3.pdf

=Découpage fonctionnel=

[[Media:DecoupageFcts2026.pdf]]

=Travail à réaliser=

==1ère partie (2 semaines)==
*travail individuel
**travail à réaliser pour fin de la 2ème semaine
**évaluation à la fin de la 2ème semaine (schéma/routage)
**sélection de la meilleure carte pour fabrication
***finalisation des pcbs pour le {{Rouge|jeudi 3/04 matin}}
*cartes :
**balise émettrice
***choix de la fréquence
**balise de réglage
***à l'opposé du terrain
***permet de régler l'élévation de la balise émettrice
***affiche le niveau de puissance
**carte réceptrice IR (filtre)
**carte filtrage (se plug sur la carte réceptrice IR)
***on change de carte pour changer la fréquence
**carte µc
***connectique pour e/s
***driver moteurs
***fourni alim symétrique
**banc test pour la carte filtre
**banc test pour la carte réceptrice complète

==2ème partie (xx jours)==

*Travail individuel
*montage des cartes
*vérification du fonctionnement
*réalisation programme : fonction à réaliser selon cdc

==3ème partie (xx jours)==

*travail en binôme ?
*programmation d'un robot

=Modalités d'évaluation=

==1 soutenance==
*Vendredi 17/05 matin
**20 minutes de présentation
**10 minutes de questions
*Présentation(introduction) de chaque "partie" en anglais

==1 dossier==
*Analyse fonctionnelle
*Nomenclature
*Chiffrage
*Etude détaillée de chaque fonction
*Schémas électriques/algorithmes/simulations/courbes caractéristiques/fonctions de transfert ...

==Démonstration(s)==

* Démonstration du fonctionnement le 12/05 à 12h
* Participation au festival de robotique à Cachan

==Note de résultat - Evaluation travaux de SAE==
*Groupe : accomplissement du projet
*Individuelle : en fonction de
**Difficulté technique
**Quantité de travail
**Qualité de la réalisation
**Investissement : <big>évalué chaque jour</big>

==Réalisation d'une vidéo==
Vidéo à réaliser pour le concours EEA :
https://clubeea.com/concours-mon-projet-en-5-minutes/

=Fonctions=
[[Cours:SaeEvitementObstaclesFonctions]]

=Pages indispensables du wiki=

*[[Cours:Oscillogbf|Utilisation de python et Qt pour la réalisation d'un banc de test]]
*[[Cours:PiPico|Programmation de la carte pico rp2040]]
*[[Cours:Esp01|Utilisation d'un esp-01 pour faire de la supervision]]

=Ressources informatique=

*[[Cours:pixyUartArduino|Pixy]]
*https://www.waveshare.com/wiki/RPLIDAR_C1

=Ressources=

*https://www.eeweb.com/level-shifting-techniques-in-i2c-bus-design/
*https://github.com/drankinatty/pico-mpu9250

*vérifier la "programmabilité" du µcontroleur :
**dans un terminal
**avrdude -c usbasp -p nomDuMicro
**ex : avrdude -c usbasp -p t2313
**ex : avrdude -c usbasp -p m328p

*modification des fusibles pour choisir fréquence d'horloge:
**pour les atmega328p, dans le logiciel graver le bootloader
**pour les attiny (utiliser '''arduino v1''' !! ) :
***installer attinycore : https://github.com/SpenceKonde/ATTinyCore/blob/v2.0.0-devThis-is-the-head-submit-PRs-against-this/Installation.md
***choisir le bon microcontroleur et la bonne source d'horloge
***graver la séquence d'initialisation
**pour les atmega2560, attention il faut modifier les fusibles par rapport au bootloader arduino :
***dans un terminal
***avrdude -v -patmega2560 -cusbasp -e -Ulock:w:0x3F:m -Uefuse:w:0xFD:m -Uhfuse:w:0xD9:m -Ulfuse:w:0xFF:m

*http://raphael.candelier.fr/?blog=XL_320

=contraintes de fabrication=

==carte alimentation==

==carte principale==

*dimension maximum : 8cm x 13cm

Cours:SaeEvitementObstacles

2026-04-07T13:14:01Z

Bjacquot :

support de présentation :
https://docs.google.com/presentation/d/1r9tSETGUbYgtk2Ip78lNhEWxcHYtDbIx4epwVoeI2hs/edit?slide=id.p#slide=id.p

fonctions :
https://docs.google.com/spreadsheets/d/1GX3zPpdC4umtqc4B8hLjQZWTMNHfw7GfKqrpxW5ORzc/edit?usp=sharing

https://www.festivalrobotiquecachan.fr/

https://www.festivalrobotiquecachan.fr/wp-content/uploads/Reglement_rencontres_de_robotique_GEII_BUT-1-2-3.pdf

=Découpage fonctionnel=

[[Media:DecoupageFcts2026.pdf]]

=Travail à réaliser=

==1ère partie (2 semaines)==
*travail individuel
**travail à réaliser pour fin de la 2ème semaine
**évaluation à la fin de la 2ème semaine (schéma/routage)
**sélection de la meilleure carte pour fabrication
***finalisation des pcbs pour le {{Rouge|jeudi 3/04 matin}}
*cartes :
**balise émettrice
***choix de la fréquence
**balise de réglage
***à l'opposé du terrain
***permet de régler l'élévation de la balise émettrice
***affiche le niveau de puissance
**carte réceptrice IR (filtre)
**carte filtrage (se plug sur la carte réceptrice IR)
***on change de carte pour changer la fréquence
**carte µc
***connectique pour e/s
***driver moteurs
***fourni alim symétrique
**banc test pour la carte filtre
**banc test pour la carte réceptrice complète

==2ème partie (xx jours)==

*Travail individuel
*montage des cartes
*vérification du fonctionnement
*réalisation programme : fonction à réaliser selon cdc

==3ème partie (xx jours)==

*travail en binôme ?
*programmation d'un robot

=Modalités d'évaluation=

==1 soutenance==
*Vendredi 17/05 matin
**20 minutes de présentation
**10 minutes de questions
*Présentation(introduction) de chaque "partie" en anglais

==1 dossier==
*Analyse fonctionnelle
*Nomenclature
*Chiffrage
*Etude détaillée de chaque fonction
*Schémas électriques/algorithmes/simulations/courbes caractéristiques/fonctions de transfert ...

==Démonstration(s)==

* Démonstration du fonctionnement le 12/05 à 12h
* Participation au festival de robotique à Cachan

==Note de résultat - Evaluation travaux de SAE==
*Groupe : accomplissement du projet
*Individuelle : en fonction de
**Difficulté technique
**Quantité de travail
**Qualité de la réalisation
**Investissement : <big>évalué chaque jour</big>

==Réalisation d'une vidéo==
Vidéo à réaliser pour le concours EEA :
https://clubeea.com/concours-mon-projet-en-5-minutes/

=Fonctions=
[[Cours:SaeEvitementObstaclesFonctions]]

=Pages indispensables du wiki=

*[[Cours:Oscillogbf|Utilisation de python et Qt pour la réalisation d'un banc de test]]
*[[Cours:PiPico|Programmation de la carte pico rp2040]]
*[[Cours:Esp01|Utilisation d'un esp-01 pour faire de la supervision]]

=Ressources informatique=

*[[Cours:pixyUartArduino|Pixy]]
*https://www.waveshare.com/wiki/RPLIDAR_C1

=Ressources=

*https://www.eeweb.com/level-shifting-techniques-in-i2c-bus-design/
*https://github.com/drankinatty/pico-mpu9250

*vérifier la "programmabilité" du µcontroleur :
**dans un terminal
**avrdude -c usbasp -p nomDuMicro
**ex : avrdude -c usbasp -p t2313
**ex : avrdude -c usbasp -p m328p

*modification des fusibles pour choisir fréquence d'horloge:
**pour les atmega328p, dans le logiciel graver le bootloader
**pour les attiny (utiliser '''arduino v1''' !! ) :
***installer attinycore : https://github.com/SpenceKonde/ATTinyCore/blob/v2.0.0-devThis-is-the-head-submit-PRs-against-this/Installation.md
***choisir le bon microcontroleur et la bonne source d'horloge
***graver la séquence d'initialisation
**pour les atmega2560, attention il faut modifier les fusibles par rapport au bootloader arduino :
***dans un terminal
***avrdude -v -patmega2560 -cusbasp -e -Ulock:w:0x3F:m -Uefuse:w:0xFD:m -Uhfuse:w:0xD9:m -Ulfuse:w:0xFF:m

*http://raphael.candelier.fr/?blog=XL_320

=contraintes de fabrication=

==carte alimentation==

==carte principale==

*dimension maximum : 8cm x 13cm

Cours:SaeEvitementObstacles

2026-04-07T13:13:08Z

Bjacquot :

Cours:SaeEvitementObstacles

2026-04-07T07:02:39Z

Bjacquot :

Cours:InfoS2 EvaluationSimulIde

2026-04-04T08:17:31Z

Bjacquot :

<accesscontrol>Acces:Prof</accesscontrol>

{{EnTeteTdInfoS2|InfoS2 tdI2cRegistres prof}}

=Identification des cibles=

Fichiers pour simulide : [[Media:I2cSlaveEvaluation.zip|I2cSlaveEvaluation.zip]]

{{Rouge|**************************************************}}
{{Rouge|*** Attention, programme dans un fichier .ino ***}}
{{Rouge|**************************************************}}
{{Rouge|*** choisir le µc Master en tant que MainMCU ***}}
{{Rouge|*** !!!! le point jaune !!!! ***}}
{{Rouge|**************************************************}}

{{Eval|1|Trouver l'adresse i2c du "slave afficheur"}}

=Utilisation du chenillard=

Le slave chenillard s'utilise de façon simple :
*on peut uniquement écrire des valeurs sur ce slave
*il n'y a pas de registres
*on enverra :
**la valeur 0 pour arrêter le chenillard
**la valeur 1 pour mettre en route le chenillard

{{Eval|1|Ecrire un programme dans le master qui :}}
*met en marche le chenillard pendant 1s
*l'arrête pendant 2s
*recommence

=Utilisation du bouton=
Le slave bouton s'utilise de façon simple :
*on peut uniquement lire des valeurs sur ce slave
*il n'y a pas de registres
*on lira :
**la valeur 0 lorsque le bouton n'est pas appuyé
**la valeur 1 lorsque le bouton est appuyé

{{Eval|2|Ecrire un programme dans le master qui :}}
*affiche la valeur du bouton sur la liaison série
*commande la mise en marche du chenillard avec le bouton
 

=Utilisation de l'afficheur 7 segments=
Le slave afficheur s'utilise de façon simple :
*on peut uniquement écrire des valeurs sur ce slave
*il y a 4 registres :
**registre {{Rouge|0}} : change la valeur des unités
**registre {{Rouge|1}} : change la valeur des dizaines
**registre {{Rouge|2}} : change la valeur des centaines
**registre {{Rouge|3}} : change la valeur des milliers

{{Eval|2|Ecrire un programme dans le master qui :}}
*affiche la valeur "1234" pendant 1s
*affiche la valeur "9876" pendant 2s
*recommence

=Utilisation du chrono=
Le slave chrono s'utilise de la façon suivante :
*on peut écrire ou lire des valeurs sur ce slave
*il n'y a pas de registres
*en écriture :
**écrire la valeur 0 permet d'arrêter le chrono
**écrire la valeur 1 permet de mettre en route le chrono et de le remettre à 0
*en lecture :
**on obtient la valeur du chronomètre
**il conviendra de multiplier la valeur lue en i2c par 8 pour obtenir la durée en ms

{{Eval|2|Ecrire un programme dans le master qui :}}
*lance le chrono
*attend 500ms
*arrête le chrono
*récupère la valeur du chrono
*affiche la valeur du chrono sur la liaison série (en ms)
*affiche la valeur du chrono sur le slave afficheur
*attend 5s avant de recommencer

=Assemblons le tout=

On réalise un jeu de réflexe : le joueur devra appuyer sur le bouton dès qu'il constate un changement sur le chenillard

{{Eval|2|Ecrire un programme correspondant à l'algorithme suivant :}}
*attendre 1s
*démarrer le chenillard
*démarrer le chrono
*attendre appui sur le bouton
*arrêter le chrono
*arrêter le chenillard
*lire le chrono
*afficher la valeur du chrono sur l'afficheur
*attendre le relâchement du bouton
*attendre 5s

Cours:InfoS2 EvaluationSimulIde

2026-04-04T08:17:13Z

Bjacquot : /* Utilisation du bouton */

{{EnTeteTdInfoS2|InfoS2 tdI2cRegistres prof}}

=Identification des cibles=

Fichiers pour simulide : [[Media:I2cSlaveEvaluation.zip|I2cSlaveEvaluation.zip]]

{{Rouge|**************************************************}}
{{Rouge|*** Attention, programme dans un fichier .ino ***}}
{{Rouge|**************************************************}}
{{Rouge|*** choisir le µc Master en tant que MainMCU ***}}
{{Rouge|*** !!!! le point jaune !!!! ***}}
{{Rouge|**************************************************}}

{{Eval|1|Trouver l'adresse i2c du "slave afficheur"}}

=Utilisation du chenillard=

Le slave chenillard s'utilise de façon simple :
*on peut uniquement écrire des valeurs sur ce slave
*il n'y a pas de registres
*on enverra :
**la valeur 0 pour arrêter le chenillard
**la valeur 1 pour mettre en route le chenillard

{{Eval|1|Ecrire un programme dans le master qui :}}
*met en marche le chenillard pendant 1s
*l'arrête pendant 2s
*recommence

=Utilisation du bouton=
Le slave bouton s'utilise de façon simple :
*on peut uniquement lire des valeurs sur ce slave
*il n'y a pas de registres
*on lira :
**la valeur 0 lorsque le bouton n'est pas appuyé
**la valeur 1 lorsque le bouton est appuyé

{{Eval|2|Ecrire un programme dans le master qui :}}
*affiche la valeur du bouton sur la liaison série
*commande la mise en marche du chenillard avec le bouton
 

=Utilisation de l'afficheur 7 segments=
Le slave afficheur s'utilise de façon simple :
*on peut uniquement écrire des valeurs sur ce slave
*il y a 4 registres :
**registre {{Rouge|0}} : change la valeur des unités
**registre {{Rouge|1}} : change la valeur des dizaines
**registre {{Rouge|2}} : change la valeur des centaines
**registre {{Rouge|3}} : change la valeur des milliers

{{Eval|2|Ecrire un programme dans le master qui :}}
*affiche la valeur "1234" pendant 1s
*affiche la valeur "9876" pendant 2s
*recommence

=Utilisation du chrono=
Le slave chrono s'utilise de la façon suivante :
*on peut écrire ou lire des valeurs sur ce slave
*il n'y a pas de registres
*en écriture :
**écrire la valeur 0 permet d'arrêter le chrono
**écrire la valeur 1 permet de mettre en route le chrono et de le remettre à 0
*en lecture :
**on obtient la valeur du chronomètre
**il conviendra de multiplier la valeur lue en i2c par 8 pour obtenir la durée en ms

{{Eval|2|Ecrire un programme dans le master qui :}}
*lance le chrono
*attend 500ms
*arrête le chrono
*récupère la valeur du chrono
*affiche la valeur du chrono sur la liaison série (en ms)
*affiche la valeur du chrono sur le slave afficheur
*attend 5s avant de recommencer

=Assemblons le tout=

On réalise un jeu de réflexe : le joueur devra appuyer sur le bouton dès qu'il constate un changement sur le chenillard

{{Eval|2|Ecrire un programme correspondant à l'algorithme suivant :}}
*attendre 1s
*démarrer le chenillard
*démarrer le chrono
*attendre appui sur le bouton
*arrêter le chrono
*arrêter le chenillard
*lire le chrono
*afficher la valeur du chrono sur l'afficheur
*attendre le relâchement du bouton
*attendre 5s

Cours:InfoS2 EvaluationSimulIde

2026-04-04T08:17:03Z

Bjacquot : Annulation des modifications 20926 de Bjacquot (discussion)

{{EnTeteTdInfoS2|InfoS2 tdI2cRegistres prof}}

=Identification des cibles=

Fichiers pour simulide : [[Media:I2cSlaveEvaluation.zip|I2cSlaveEvaluation.zip]]

{{Rouge|**************************************************}}
{{Rouge|*** Attention, programme dans un fichier .ino ***}}
{{Rouge|**************************************************}}
{{Rouge|*** choisir le µc Master en tant que MainMCU ***}}
{{Rouge|*** !!!! le point jaune !!!! ***}}
{{Rouge|**************************************************}}

{{Eval|1|Trouver l'adresse i2c du "slave afficheur"}}

=Utilisation du chenillard=

Le slave chenillard s'utilise de façon simple :
*on peut uniquement écrire des valeurs sur ce slave
*il n'y a pas de registres
*on enverra :
**la valeur 0 pour arrêter le chenillard
**la valeur 1 pour mettre en route le chenillard

{{Eval|1|Ecrire un programme dans le master qui :}}
*met en marche le chenillard pendant 1s
*l'arrête pendant 2s
*recommence

=Utilisation du bouton=
Le slave chenillard s'utilise de façon simple :
*on peut uniquement lire des valeurs sur ce slave
*il n'y a pas de registres
*on lira :
**la valeur 0 lorsque le bouton n'est pas appuyé
**la valeur 1 lorsque le bouton est appuyé

{{Eval|2|Ecrire un programme dans le master qui :}}
*affiche la valeur du bouton sur la liaison série
*commande la mise en marche du chenillard avec le bouton
 

=Utilisation de l'afficheur 7 segments=
Le slave afficheur s'utilise de façon simple :
*on peut uniquement écrire des valeurs sur ce slave
*il y a 4 registres :
**registre {{Rouge|0}} : change la valeur des unités
**registre {{Rouge|1}} : change la valeur des dizaines
**registre {{Rouge|2}} : change la valeur des centaines
**registre {{Rouge|3}} : change la valeur des milliers

{{Eval|2|Ecrire un programme dans le master qui :}}
*affiche la valeur "1234" pendant 1s
*affiche la valeur "9876" pendant 2s
*recommence

=Utilisation du chrono=
Le slave chrono s'utilise de la façon suivante :
*on peut écrire ou lire des valeurs sur ce slave
*il n'y a pas de registres
*en écriture :
**écrire la valeur 0 permet d'arrêter le chrono
**écrire la valeur 1 permet de mettre en route le chrono et de le remettre à 0
*en lecture :
**on obtient la valeur du chronomètre
**il conviendra de multiplier la valeur lue en i2c par 8 pour obtenir la durée en ms

{{Eval|2|Ecrire un programme dans le master qui :}}
*lance le chrono
*attend 500ms
*arrête le chrono
*récupère la valeur du chrono
*affiche la valeur du chrono sur la liaison série (en ms)
*affiche la valeur du chrono sur le slave afficheur
*attend 5s avant de recommencer

=Assemblons le tout=

On réalise un jeu de réflexe : le joueur devra appuyer sur le bouton dès qu'il constate un changement sur le chenillard

{{Eval|2|Ecrire un programme correspondant à l'algorithme suivant :}}
*attendre 1s
*démarrer le chenillard
*démarrer le chrono
*attendre appui sur le bouton
*arrêter le chrono
*arrêter le chenillard
*lire le chrono
*afficher la valeur du chrono sur l'afficheur
*attendre le relâchement du bouton
*attendre 5s

Cours:InfoS2 EvaluationSimulIde

2026-04-04T08:16:40Z

Bjacquot : Révocation des modifications de Bjacquot (discussion) vers la dernière version de Fredmn

<accesscontrol>Acces:Prof</accesscontrol>

{{EnTeteTdInfoS2|InfoS2 tdI2cRegistres prof}}

=Identification des cibles=

Fichiers pour simulide : [[Media:I2cSlaveEvaluation.zip|I2cSlaveEvaluation.zip]]

{{Rouge|**************************************************}}
{{Rouge|*** Attention, programme dans un fichier .ino ***}}
{{Rouge|**************************************************}}
{{Rouge|*** choisir le µc Master en tant que MainMCU ***}}
{{Rouge|*** !!!! le point jaune !!!! ***}}
{{Rouge|**************************************************}}

{{Eval|1|Trouver l'adresse i2c du "slave afficheur"}}

=Utilisation du chenillard=

Le slave chenillard s'utilise de façon simple :
*on peut uniquement écrire des valeurs sur ce slave
*on enverra :
**la valeur 0 pour arrêter le chenillard
**la valeur 1 pour mettre en route le chenillard

{{Eval|1|Ecrire un programme dans le master qui :}}
*met en marche le chenillard pendant 1s
*l'arrête pendant 2s
*recommence

=Utilisation du bouton=
Le slave chenillard s'utilise de façon simple :
*on peut uniquement lire des valeurs sur ce slave
*on lira :
**la valeur 0 lorsque le bouton n'est pas appuyé
**la valeur 1 lorsque le bouton est appuyé

{{Eval|2|Ecrire un programme dans le master qui :}}
*affiche la valeur du bouton sur la liaison série
*commande la mise en marche du chenillard avec le bouton

=Utilisation de l'afficheur 7 segments=
Le slave afficheur s'utilise de façon simple :
*on peut uniquement écrire des valeurs sur ce slave
*il y a 4 registres :
**registre {{Rouge|0}} : change la valeur des unités
**registre {{Rouge|1}} : change la valeur des dizaines
**registre {{Rouge|2}} : change la valeur des centaines
**registre {{Rouge|3}} : change la valeur des milliers

{{Eval|2|Ecrire un programme dans le master qui :}}
*affiche la valeur "1234" pendant 1s
*affiche la valeur "9876" pendant 2s
*recommence

=Utilisation du chrono=
Le slave chrono s'utilise de la façon suivante :
*on peut écrire ou lire des valeurs sur ce slave
*en écriture :
**écrire la valeur 0 permet d'arrêter le chrono
**écrire la valeur 1 permet de mettre en route le chrono et de le remettre à 0
*en lecture :
**on obtient la valeur du chronomètre
**il conviendra de multiplier la valeur lue en i2c par 8 pour obtenir la durée en ms

{{Eval|2|Ecrire un programme dans le master qui :}}
*lance le chrono
*attend 500ms
*arrête le chrono
*récupère la valeur du chrono
*affiche la valeur du chrono sur la liaison série (en ms)
*affiche la valeur du chrono sur le slave afficheur
*attend 5s avant de recommencer

=Assemblons le tout=

On réalise un jeu de réflexe : le joueur devra appuyer sur le bouton dès qu'il constate un changement sur le chenillard

{{Eval|2|Ecrire un programme correspondant à l'algorithme suivant :}}
*attendre 1s
*démarrer le chenillard
*démarrer le chrono
*attendre appui sur le bouton
*arrêter le chrono
*arrêter le chenillard
*lire le chrono
*afficher la valeur du chrono sur l'afficheur
*attendre le relâchement du bouton
*attendre 5s

Cours:DocsLTSP

2026-04-03T17:43:30Z

Bjacquot : /* firefox */

=mise à jour=

*préparer les mises à jour
**dans le menu de bootreseau
**choisir "installer mise a jour Ubuntu"
**mettre à jour le noyau avec : updateKernelReseau
*vérifier les mises à jour
**dans le menu de bootreseau
**choisir "verifier apres mise a jour Ubuntu"
*passer sur la nouvelle version
**après vérifications
**lancer la commande : updateBootReseau

=Installation=
https://wiki.defis.info/?LTSPInstall

*installation ltsp https://ltsp.org/docs/installation/
*debootstrap ubuntu

**https://github.com/ltsp/ltsp/wiki/chroots
<source lang=bash>
mkdir /srv/ltsp
cd /srv/ltsp
debootstrap --include ubuntu-minimal noble noble
//config schroot
schroot
// continuer avec l'installation de paquets, par ex https://help.ubuntu.com/community/DebootstrapChroot
</source>

*config ltsp
**ltsp dnsmasq
**ltsp ipxe
**ltsp initrd
**ltsp kernel
**ltsp nfs

*ltsp initrd :
**update ltsp.img
**modifie users

<source lang=bash>

</source>

=groupes utilisateurs=
modifier le fichier : /etc/security/group.conf

=tftp from grub=

*https://gist.github.com/maccadia/e5faa903f591a089c1c65be381619118

=virt-viewer=
*https://www.apalrd.net/posts/2022/raspi_spice/

<source lang=bash>
#!/bin/bash
set -e

# Set auth options
PASSWORD='xxxxxxxx'
USERNAME='spiceUser@pve'

# Set VM ID
VMID="102"

# Set Node
# This must either be a DNS address or name of the node in the cluster
NODE="geii-node2-svr"

# Proxy equals node if node is a DNS address
# Otherwise, you need to set the IP address of the node here
PROXY="10.98.35.249"

#The rest of the script from Proxmox
NODE="${NODE%%\.*}"

DATA="$(curl -f -s -S -k --data-urlencode "username=$USERNAME" --data-urlencode "password=$PASSWORD" "https://$PROXY:8006/api2/json/access/ticket")"

echo "AUTH OK"

TICKET="${DATA//\"/}"
TICKET="${TICKET##*ticket:}"
TICKET="${TICKET%%,*}"
TICKET="${TICKET%%\}*}"

CSRF="${DATA//\"/}"
CSRF="${CSRF##*CSRFPreventionToken:}"
CSRF="${CSRF%%,*}"
CSRF="${CSRF%%\}*}"

curl -f -s -S -k -b "PVEAuthCookie=$TICKET" -H "CSRFPreventionToken: $CSRF" "https://$PROXY:8006/api2/spiceconfig/nodes/$NODE/qemu/$VMID/spiceproxy" -d "proxy=$PROXY" > spiceproxy

#Launch remote-viewer with spiceproxy file, in kiosk mode, quit on disconnect
#The run loop will get a new ticket and launch us again if we disconnect
exec remote-viewer -k --kiosk-quit on-disconnect spiceproxy

</source>

=initrd nfs v4=
*https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=409272
*https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=409272

=divers=

The most common iPXE boot loaders are undionly.kpxe (for bios) and snp.efi/snponly.efi (for usefi). Just be aware you can not boot a bios bootloader (undionly.kpxe) on a uefi system unless CSM is enabled. But then CSM would boot in bios mode. The same is the case for snp.efi, it will not boot on a bios based computer.

https://wiki.fogproject.org/wiki/index.php?title=ProxyDHCP_with_dnsmasq

https://wiki.ubuntu.com/LTSPLocalAppSetup

http://wiki.bluelightav.org/pages/viewpage.action?pageId=23626143

=grub=

<source lang=bash>
menuentry "LTSP Network Boot"
{
insmod net
insmod efinet
insmod tftp
insmod pxeboot
net_bootp linux (tftp,<IP_SERVEUR>)/ltsp/x86_64/vmlinuz initrd=/ltsp/x86_64/initrd.img root=/dev/nfs nfsroot=<IP_SERVEUR>:/opt/ltsp rootfstype=nfs ip=dhcp
initrd (tftp,<IP_SERVEUR>)/ltsp/x86_64/initrd.img
}
</source>

=optimisation=

==firefox==

<source lang=bash>
nano /usr/lib/firefox/distribution/policies.json

{
"policies": {
"DisableTelemetry": true,
"Preferences": {
"browser.cache.disk.enable": false,
"browser.cache.memory.enable": true,
"browser.cache.offline.enable": false,
"browser.sessionstore.interval": 600000,
"network.http.pipelining": true

}
}
}

nano /usr/lib/firefox/mozilla.cfg

lockPref("browser.cache.disk.enable", false);
defaultPref("browser.cache.memory.enable", true);
lockPref("browser.cache.offline.enable", false);

</source>

Cours:DocsLTSP

2026-04-03T17:37:30Z

Bjacquot : /* firefox */

=mise à jour=

*préparer les mises à jour
**dans le menu de bootreseau
**choisir "installer mise a jour Ubuntu"
**mettre à jour le noyau avec : updateKernelReseau
*vérifier les mises à jour
**dans le menu de bootreseau
**choisir "verifier apres mise a jour Ubuntu"
*passer sur la nouvelle version
**après vérifications
**lancer la commande : updateBootReseau

=Installation=
https://wiki.defis.info/?LTSPInstall

*installation ltsp https://ltsp.org/docs/installation/
*debootstrap ubuntu

**https://github.com/ltsp/ltsp/wiki/chroots
<source lang=bash>
mkdir /srv/ltsp
cd /srv/ltsp
debootstrap --include ubuntu-minimal noble noble
//config schroot
schroot
// continuer avec l'installation de paquets, par ex https://help.ubuntu.com/community/DebootstrapChroot
</source>

*config ltsp
**ltsp dnsmasq
**ltsp ipxe
**ltsp initrd
**ltsp kernel
**ltsp nfs

*ltsp initrd :
**update ltsp.img
**modifie users

<source lang=bash>

</source>

=groupes utilisateurs=
modifier le fichier : /etc/security/group.conf

=tftp from grub=

*https://gist.github.com/maccadia/e5faa903f591a089c1c65be381619118

=virt-viewer=
*https://www.apalrd.net/posts/2022/raspi_spice/

<source lang=bash>
#!/bin/bash
set -e

# Set auth options
PASSWORD='xxxxxxxx'
USERNAME='spiceUser@pve'

# Set VM ID
VMID="102"

# Set Node
# This must either be a DNS address or name of the node in the cluster
NODE="geii-node2-svr"

# Proxy equals node if node is a DNS address
# Otherwise, you need to set the IP address of the node here
PROXY="10.98.35.249"

#The rest of the script from Proxmox
NODE="${NODE%%\.*}"

DATA="$(curl -f -s -S -k --data-urlencode "username=$USERNAME" --data-urlencode "password=$PASSWORD" "https://$PROXY:8006/api2/json/access/ticket")"

echo "AUTH OK"

TICKET="${DATA//\"/}"
TICKET="${TICKET##*ticket:}"
TICKET="${TICKET%%,*}"
TICKET="${TICKET%%\}*}"

CSRF="${DATA//\"/}"
CSRF="${CSRF##*CSRFPreventionToken:}"
CSRF="${CSRF%%,*}"
CSRF="${CSRF%%\}*}"

curl -f -s -S -k -b "PVEAuthCookie=$TICKET" -H "CSRFPreventionToken: $CSRF" "https://$PROXY:8006/api2/spiceconfig/nodes/$NODE/qemu/$VMID/spiceproxy" -d "proxy=$PROXY" > spiceproxy

#Launch remote-viewer with spiceproxy file, in kiosk mode, quit on disconnect
#The run loop will get a new ticket and launch us again if we disconnect
exec remote-viewer -k --kiosk-quit on-disconnect spiceproxy

</source>

=initrd nfs v4=
*https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=409272
*https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=409272

=divers=

The most common iPXE boot loaders are undionly.kpxe (for bios) and snp.efi/snponly.efi (for usefi). Just be aware you can not boot a bios bootloader (undionly.kpxe) on a uefi system unless CSM is enabled. But then CSM would boot in bios mode. The same is the case for snp.efi, it will not boot on a bios based computer.

https://wiki.fogproject.org/wiki/index.php?title=ProxyDHCP_with_dnsmasq

https://wiki.ubuntu.com/LTSPLocalAppSetup

http://wiki.bluelightav.org/pages/viewpage.action?pageId=23626143

=grub=

<source lang=bash>
menuentry "LTSP Network Boot"
{
insmod net
insmod efinet
insmod tftp
insmod pxeboot
net_bootp linux (tftp,<IP_SERVEUR>)/ltsp/x86_64/vmlinuz initrd=/ltsp/x86_64/initrd.img root=/dev/nfs nfsroot=<IP_SERVEUR>:/opt/ltsp rootfstype=nfs ip=dhcp
initrd (tftp,<IP_SERVEUR>)/ltsp/x86_64/initrd.img
}
</source>

=optimisation=

==firefox==

<source lang=bash>
nano /usr/lib/firefox/distribution/policies.json

{
"policies": {
"DisableTelemetry": true,
"Preferences": {
"browser.cache.disk.enable": false,
"browser.cache.memory.enable": true,
"browser.cache.offline.enable": false
}
}
}

nano /usr/lib/firefox/mozilla.cfg

lockPref("browser.cache.disk.enable", false);
defaultPref("browser.cache.memory.enable", true);
lockPref("browser.cache.offline.enable", false);

</source>

Cours:DocsLTSP

2026-04-03T17:37:20Z

Bjacquot : /* grub */

=mise à jour=

*préparer les mises à jour
**dans le menu de bootreseau
**choisir "installer mise a jour Ubuntu"
**mettre à jour le noyau avec : updateKernelReseau
*vérifier les mises à jour
**dans le menu de bootreseau
**choisir "verifier apres mise a jour Ubuntu"
*passer sur la nouvelle version
**après vérifications
**lancer la commande : updateBootReseau

=Installation=
https://wiki.defis.info/?LTSPInstall

*installation ltsp https://ltsp.org/docs/installation/
*debootstrap ubuntu

**https://github.com/ltsp/ltsp/wiki/chroots
<source lang=bash>
mkdir /srv/ltsp
cd /srv/ltsp
debootstrap --include ubuntu-minimal noble noble
//config schroot
schroot
// continuer avec l'installation de paquets, par ex https://help.ubuntu.com/community/DebootstrapChroot
</source>

*config ltsp
**ltsp dnsmasq
**ltsp ipxe
**ltsp initrd
**ltsp kernel
**ltsp nfs

*ltsp initrd :
**update ltsp.img
**modifie users

<source lang=bash>

</source>

=groupes utilisateurs=
modifier le fichier : /etc/security/group.conf

=tftp from grub=

*https://gist.github.com/maccadia/e5faa903f591a089c1c65be381619118

=virt-viewer=
*https://www.apalrd.net/posts/2022/raspi_spice/

<source lang=bash>
#!/bin/bash
set -e

# Set auth options
PASSWORD='xxxxxxxx'
USERNAME='spiceUser@pve'

# Set VM ID
VMID="102"

# Set Node
# This must either be a DNS address or name of the node in the cluster
NODE="geii-node2-svr"

# Proxy equals node if node is a DNS address
# Otherwise, you need to set the IP address of the node here
PROXY="10.98.35.249"

#The rest of the script from Proxmox
NODE="${NODE%%\.*}"

DATA="$(curl -f -s -S -k --data-urlencode "username=$USERNAME" --data-urlencode "password=$PASSWORD" "https://$PROXY:8006/api2/json/access/ticket")"

echo "AUTH OK"

TICKET="${DATA//\"/}"
TICKET="${TICKET##*ticket:}"
TICKET="${TICKET%%,*}"
TICKET="${TICKET%%\}*}"

CSRF="${DATA//\"/}"
CSRF="${CSRF##*CSRFPreventionToken:}"
CSRF="${CSRF%%,*}"
CSRF="${CSRF%%\}*}"

curl -f -s -S -k -b "PVEAuthCookie=$TICKET" -H "CSRFPreventionToken: $CSRF" "https://$PROXY:8006/api2/spiceconfig/nodes/$NODE/qemu/$VMID/spiceproxy" -d "proxy=$PROXY" > spiceproxy

#Launch remote-viewer with spiceproxy file, in kiosk mode, quit on disconnect
#The run loop will get a new ticket and launch us again if we disconnect
exec remote-viewer -k --kiosk-quit on-disconnect spiceproxy

</source>

=initrd nfs v4=
*https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=409272
*https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=409272

=divers=

The most common iPXE boot loaders are undionly.kpxe (for bios) and snp.efi/snponly.efi (for usefi). Just be aware you can not boot a bios bootloader (undionly.kpxe) on a uefi system unless CSM is enabled. But then CSM would boot in bios mode. The same is the case for snp.efi, it will not boot on a bios based computer.

https://wiki.fogproject.org/wiki/index.php?title=ProxyDHCP_with_dnsmasq

https://wiki.ubuntu.com/LTSPLocalAppSetup

http://wiki.bluelightav.org/pages/viewpage.action?pageId=23626143

=grub=

<source lang=bash>
menuentry "LTSP Network Boot"
{
insmod net
insmod efinet
insmod tftp
insmod pxeboot
net_bootp linux (tftp,<IP_SERVEUR>)/ltsp/x86_64/vmlinuz initrd=/ltsp/x86_64/initrd.img root=/dev/nfs nfsroot=<IP_SERVEUR>:/opt/ltsp rootfstype=nfs ip=dhcp
initrd (tftp,<IP_SERVEUR>)/ltsp/x86_64/initrd.img
}
</source>

=optimisation=

==firefox==

<source lang=bash>
nano /usr/lib/firefox/distribution/policies.json

{
"policies": {
"DisableTelemetry": true,
"Preferences": {
"browser.cache.disk.enable": false,
"browser.cache.memory.enable": true,
"browser.cache.offline.enable": false
}
}
}

nano /usr/lib/firefox/mozilla.cfg

lockPref("browser.cache.disk.enable", false);
defaultPref("browser.cache.memory.enable", true);
lockPref("browser.cache.offline.enable", false);

Cours:InfoS2 EvaluationSimulIde

2026-04-03T07:35:17Z

Bjacquot :

{{EnTeteTdInfoS2|InfoS2 tdI2cRegistres prof}}

=Identification des cibles=

Fichiers pour simulide : [[Media:I2cSlaveEvaluation.zip|I2cSlaveEvaluation.zip]]

{{Rouge|**************************************************}}
{{Rouge|*** Attention, programme dans un fichier .ino ***}}
{{Rouge|**************************************************}}
{{Rouge|*** choisir le µc Master en tant que MainMCU ***}}
{{Rouge|*** !!!! le point jaune !!!! ***}}
{{Rouge|**************************************************}}

{{Eval|1|Trouver l'adresse i2c du "slave afficheur"}}

=Utilisation du chenillard=

Le slave chenillard s'utilise de façon simple :
*on peut uniquement écrire des valeurs sur ce slave
*il n'y a pas de registres
*on enverra :
**la valeur 0 pour arrêter le chenillard
**la valeur 1 pour mettre en route le chenillard

{{Eval|1|Ecrire un programme dans le master qui :}}
*met en marche le chenillard pendant 1s
*l'arrête pendant 2s
*recommence

=Utilisation du bouton=
Le slave chenillard s'utilise de façon simple :
*on peut uniquement lire des valeurs sur ce slave
*il n'y a pas de registres
*on lira :
**la valeur 0 lorsque le bouton n'est pas appuyé
**la valeur 1 lorsque le bouton est appuyé

{{Eval|2|Ecrire un programme dans le master qui :}}
*affiche la valeur du bouton sur la liaison série
*commande la mise en marche du chenillard avec le bouton
 

=Utilisation de l'afficheur 7 segments=
Le slave afficheur s'utilise de façon simple :
*on peut uniquement écrire des valeurs sur ce slave
*il y a 4 registres :
**registre {{Rouge|0}} : change la valeur des unités
**registre {{Rouge|1}} : change la valeur des dizaines
**registre {{Rouge|2}} : change la valeur des centaines
**registre {{Rouge|3}} : change la valeur des milliers

{{Eval|2|Ecrire un programme dans le master qui :}}
*affiche la valeur "1234" pendant 1s
*affiche la valeur "9876" pendant 2s
*recommence

=Utilisation du chrono=
Le slave chrono s'utilise de la façon suivante :
*on peut écrire ou lire des valeurs sur ce slave
*il n'y a pas de registres
*en écriture :
**écrire la valeur 0 permet d'arrêter le chrono
**écrire la valeur 1 permet de mettre en route le chrono et de le remettre à 0
*en lecture :
**on obtient la valeur du chronomètre
**il conviendra de multiplier la valeur lue en i2c par 8 pour obtenir la durée en ms

{{Eval|2|Ecrire un programme dans le master qui :}}
*lance le chrono
*attend 500ms
*arrête le chrono
*récupère la valeur du chrono
*affiche la valeur du chrono sur la liaison série (en ms)
*affiche la valeur du chrono sur le slave afficheur
*attend 5s avant de recommencer

=Assemblons le tout=

On réalise un jeu de réflexe : le joueur devra appuyer sur le bouton dès qu'il constate un changement sur le chenillard

{{Eval|2|Ecrire un programme correspondant à l'algorithme suivant :}}
*attendre 1s
*démarrer le chenillard
*démarrer le chrono
*attendre appui sur le bouton
*arrêter le chrono
*arrêter le chenillard
*lire le chrono
*afficher la valeur du chrono sur l'afficheur
*attendre le relâchement du bouton
*attendre 5s

Cours:InfoS2 EvaluationSimulIde

2026-04-03T07:13:32Z

Bjacquot : /* Utilisation du bouton */

<accesscontrol>Acces:Prof</accesscontrol>

{{EnTeteTdInfoS2|InfoS2 tdI2cRegistres prof}}

=Identification des cibles=

Fichiers pour simulide : [[Media:I2cSlaveEvaluation.zip|I2cSlaveEvaluation.zip]]

{{Rouge|**************************************************}}
{{Rouge|*** Attention, programme dans un fichier .ino ***}}
{{Rouge|**************************************************}}
{{Rouge|*** choisir le µc Master en tant que MainMCU ***}}
{{Rouge|*** !!!! le point jaune !!!! ***}}
{{Rouge|**************************************************}}

{{Eval|1|Trouver l'adresse i2c du "slave afficheur"}}

=Utilisation du chenillard=

Le slave chenillard s'utilise de façon simple :
*on peut uniquement écrire des valeurs sur ce slave
*il n'y a pas de registres
*on enverra :
**la valeur 0 pour arrêter le chenillard
**la valeur 1 pour mettre en route le chenillard

{{Eval|1|Ecrire un programme dans le master qui :}}
*met en marche le chenillard pendant 1s
*l'arrête pendant 2s
*recommence

=Utilisation du bouton=
Le slave chenillard s'utilise de façon simple :
*on peut uniquement lire des valeurs sur ce slave
*il n'y a pas de registres
*on lira :
**la valeur 0 lorsque le bouton n'est pas appuyé
**la valeur 1 lorsque le bouton est appuyé

{{Eval|2|Ecrire un programme dans le master qui :}}
*affiche la valeur du bouton sur la liaison série
*commande la mise en marche du chenillard avec le bouton
 

=Utilisation de l'afficheur 7 segments=
Le slave afficheur s'utilise de façon simple :
*on peut uniquement écrire des valeurs sur ce slave
*il y a 4 registres :
**registre {{Rouge|0}} : change la valeur des unités
**registre {{Rouge|1}} : change la valeur des dizaines
**registre {{Rouge|2}} : change la valeur des centaines
**registre {{Rouge|3}} : change la valeur des milliers

{{Eval|2|Ecrire un programme dans le master qui :}}
*affiche la valeur "1234" pendant 1s
*affiche la valeur "9876" pendant 2s
*recommence

=Utilisation du chrono=
Le slave chrono s'utilise de la façon suivante :
*on peut écrire ou lire des valeurs sur ce slave
*il n'y a pas de registres
*en écriture :
**écrire la valeur 0 permet d'arrêter le chrono
**écrire la valeur 1 permet de mettre en route le chrono et de le remettre à 0
*en lecture :
**on obtient la valeur du chronomètre
**il conviendra de multiplier la valeur lue en i2c par 8 pour obtenir la durée en ms

{{Eval|2|Ecrire un programme dans le master qui :}}
*lance le chrono
*attend 500ms
*arrête le chrono
*récupère la valeur du chrono
*affiche la valeur du chrono sur la liaison série (en ms)
*affiche la valeur du chrono sur le slave afficheur
*attend 5s avant de recommencer

=Assemblons le tout=

On réalise un jeu de réflexe : le joueur devra appuyer sur le bouton dès qu'il constate un changement sur le chenillard

{{Eval|2|Ecrire un programme correspondant à l'algorithme suivant :}}
*attendre 1s
*démarrer le chenillard
*démarrer le chrono
*attendre appui sur le bouton
*arrêter le chrono
*arrêter le chenillard
*lire le chrono
*afficher la valeur du chrono sur l'afficheur
*attendre le relâchement du bouton
*attendre 5s

Acces:Prof

2026-04-02T13:15:26Z

Bjacquot :

*bjacquot
*AgnesD
*f.sisternas
*sl
*bernar03
*Gmillon
*Remy02
*Woznyrob
*penant
*fredmn
*vuille01
*nawal
*Tarek

Cours:InfoS2 EvaluationSimulIde

2026-04-01T13:52:17Z

Bjacquot : /* Utilisation du chrono */

<accesscontrol>Acces:Prof</accesscontrol>

{{EnTeteTdInfoS2|InfoS2 tdI2cRegistres prof}}

=Identification des cibles=

Fichiers pour simulide : [[Media:I2cSlaveEvaluation.zip|I2cSlaveEvaluation.zip]]

{{Rouge|**************************************************}}
{{Rouge|*** Attention, programme dans un fichier .ino ***}}
{{Rouge|**************************************************}}
{{Rouge|*** choisir le µc Master en tant que MainMCU ***}}
{{Rouge|*** !!!! le point jaune !!!! ***}}
{{Rouge|**************************************************}}

{{Eval|1|Trouver l'adresse i2c du "slave afficheur"}}

=Utilisation du chenillard=

Le slave chenillard s'utilise de façon simple :
*on peut uniquement écrire des valeurs sur ce slave
*il n'y a pas de registres
*on enverra :
**la valeur 0 pour arrêter le chenillard
**la valeur 1 pour mettre en route le chenillard

{{Eval|1|Ecrire un programme dans le master qui :}}
*met en marche le chenillard pendant 1s
*l'arrête pendant 2s
*recommence

=Utilisation du bouton=
Le slave chenillard s'utilise de façon simple :
*on peut uniquement lire des valeurs sur ce slave
*il n'y a pas de registres
*on lira :
**la valeur 0 lorsque le bouton n'est pas appuyé
**la valeur 1 lorsque le bouton est appuyé

{{Eval|2|Ecrire un programme dans le master qui :}}
*affiche la valeur du bouton sur la liaison série
*commande la mise en marche du chenillard avec le bouton

=Utilisation de l'afficheur 7 segments=
Le slave afficheur s'utilise de façon simple :
*on peut uniquement écrire des valeurs sur ce slave
*il y a 4 registres :
**registre {{Rouge|0}} : change la valeur des unités
**registre {{Rouge|1}} : change la valeur des dizaines
**registre {{Rouge|2}} : change la valeur des centaines
**registre {{Rouge|3}} : change la valeur des milliers

{{Eval|2|Ecrire un programme dans le master qui :}}
*affiche la valeur "1234" pendant 1s
*affiche la valeur "9876" pendant 2s
*recommence

=Utilisation du chrono=
Le slave chrono s'utilise de la façon suivante :
*on peut écrire ou lire des valeurs sur ce slave
*il n'y a pas de registres
*en écriture :
**écrire la valeur 0 permet d'arrêter le chrono
**écrire la valeur 1 permet de mettre en route le chrono et de le remettre à 0
*en lecture :
**on obtient la valeur du chronomètre
**il conviendra de multiplier la valeur lue en i2c par 8 pour obtenir la durée en ms

{{Eval|2|Ecrire un programme dans le master qui :}}
*lance le chrono
*attend 500ms
*arrête le chrono
*récupère la valeur du chrono
*affiche la valeur du chrono sur la liaison série (en ms)
*affiche la valeur du chrono sur le slave afficheur
*attend 5s avant de recommencer

=Assemblons le tout=

On réalise un jeu de réflexe : le joueur devra appuyer sur le bouton dès qu'il constate un changement sur le chenillard

{{Eval|2|Ecrire un programme correspondant à l'algorithme suivant :}}
*attendre 1s
*démarrer le chenillard
*démarrer le chrono
*attendre appui sur le bouton
*arrêter le chrono
*arrêter le chenillard
*lire le chrono
*afficher la valeur du chrono sur l'afficheur
*attendre le relâchement du bouton
*attendre 5s

Cours:InfoS2 EvaluationSimulIde

2026-04-01T13:52:01Z

Bjacquot : /* Utilisation du bouton */

<accesscontrol>Acces:Prof</accesscontrol>

{{EnTeteTdInfoS2|InfoS2 tdI2cRegistres prof}}

=Identification des cibles=

Fichiers pour simulide : [[Media:I2cSlaveEvaluation.zip|I2cSlaveEvaluation.zip]]

{{Rouge|**************************************************}}
{{Rouge|*** Attention, programme dans un fichier .ino ***}}
{{Rouge|**************************************************}}
{{Rouge|*** choisir le µc Master en tant que MainMCU ***}}
{{Rouge|*** !!!! le point jaune !!!! ***}}
{{Rouge|**************************************************}}

{{Eval|1|Trouver l'adresse i2c du "slave afficheur"}}

=Utilisation du chenillard=

Le slave chenillard s'utilise de façon simple :
*on peut uniquement écrire des valeurs sur ce slave
*il n'y a pas de registres
*on enverra :
**la valeur 0 pour arrêter le chenillard
**la valeur 1 pour mettre en route le chenillard

{{Eval|1|Ecrire un programme dans le master qui :}}
*met en marche le chenillard pendant 1s
*l'arrête pendant 2s
*recommence

=Utilisation du bouton=
Le slave chenillard s'utilise de façon simple :
*on peut uniquement lire des valeurs sur ce slave
*il n'y a pas de registres
*on lira :
**la valeur 0 lorsque le bouton n'est pas appuyé
**la valeur 1 lorsque le bouton est appuyé

{{Eval|2|Ecrire un programme dans le master qui :}}
*affiche la valeur du bouton sur la liaison série
*commande la mise en marche du chenillard avec le bouton

=Utilisation de l'afficheur 7 segments=
Le slave afficheur s'utilise de façon simple :
*on peut uniquement écrire des valeurs sur ce slave
*il y a 4 registres :
**registre {{Rouge|0}} : change la valeur des unités
**registre {{Rouge|1}} : change la valeur des dizaines
**registre {{Rouge|2}} : change la valeur des centaines
**registre {{Rouge|3}} : change la valeur des milliers

{{Eval|2|Ecrire un programme dans le master qui :}}
*affiche la valeur "1234" pendant 1s
*affiche la valeur "9876" pendant 2s
*recommence

=Utilisation du chrono=
Le slave chrono s'utilise de la façon suivante :
*on peut écrire ou lire des valeurs sur ce slave
*en écriture :
**écrire la valeur 0 permet d'arrêter le chrono
**écrire la valeur 1 permet de mettre en route le chrono et de le remettre à 0
*en lecture :
**on obtient la valeur du chronomètre
**il conviendra de multiplier la valeur lue en i2c par 8 pour obtenir la durée en ms

{{Eval|2|Ecrire un programme dans le master qui :}}
*lance le chrono
*attend 500ms
*arrête le chrono
*récupère la valeur du chrono
*affiche la valeur du chrono sur la liaison série (en ms)
*affiche la valeur du chrono sur le slave afficheur
*attend 5s avant de recommencer

=Assemblons le tout=

On réalise un jeu de réflexe : le joueur devra appuyer sur le bouton dès qu'il constate un changement sur le chenillard

{{Eval|2|Ecrire un programme correspondant à l'algorithme suivant :}}
*attendre 1s
*démarrer le chenillard
*démarrer le chrono
*attendre appui sur le bouton
*arrêter le chrono
*arrêter le chenillard
*lire le chrono
*afficher la valeur du chrono sur l'afficheur
*attendre le relâchement du bouton
*attendre 5s

Cours:InfoS2 EvaluationSimulIde

2026-04-01T13:51:53Z

Bjacquot : /* Utilisation du chenillard */

<accesscontrol>Acces:Prof</accesscontrol>

{{EnTeteTdInfoS2|InfoS2 tdI2cRegistres prof}}

=Identification des cibles=

Fichiers pour simulide : [[Media:I2cSlaveEvaluation.zip|I2cSlaveEvaluation.zip]]

{{Rouge|**************************************************}}
{{Rouge|*** Attention, programme dans un fichier .ino ***}}
{{Rouge|**************************************************}}
{{Rouge|*** choisir le µc Master en tant que MainMCU ***}}
{{Rouge|*** !!!! le point jaune !!!! ***}}
{{Rouge|**************************************************}}

{{Eval|1|Trouver l'adresse i2c du "slave afficheur"}}

=Utilisation du chenillard=

Le slave chenillard s'utilise de façon simple :
*on peut uniquement écrire des valeurs sur ce slave
*il n'y a pas de registres
*on enverra :
**la valeur 0 pour arrêter le chenillard
**la valeur 1 pour mettre en route le chenillard

{{Eval|1|Ecrire un programme dans le master qui :}}
*met en marche le chenillard pendant 1s
*l'arrête pendant 2s
*recommence

=Utilisation du bouton=
Le slave chenillard s'utilise de façon simple :
*on peut uniquement lire des valeurs sur ce slave
*on lira :
**la valeur 0 lorsque le bouton n'est pas appuyé
**la valeur 1 lorsque le bouton est appuyé

{{Eval|2|Ecrire un programme dans le master qui :}}
*affiche la valeur du bouton sur la liaison série
*commande la mise en marche du chenillard avec le bouton

=Utilisation de l'afficheur 7 segments=
Le slave afficheur s'utilise de façon simple :
*on peut uniquement écrire des valeurs sur ce slave
*il y a 4 registres :
**registre {{Rouge|0}} : change la valeur des unités
**registre {{Rouge|1}} : change la valeur des dizaines
**registre {{Rouge|2}} : change la valeur des centaines
**registre {{Rouge|3}} : change la valeur des milliers

{{Eval|2|Ecrire un programme dans le master qui :}}
*affiche la valeur "1234" pendant 1s
*affiche la valeur "9876" pendant 2s
*recommence

=Utilisation du chrono=
Le slave chrono s'utilise de la façon suivante :
*on peut écrire ou lire des valeurs sur ce slave
*en écriture :
**écrire la valeur 0 permet d'arrêter le chrono
**écrire la valeur 1 permet de mettre en route le chrono et de le remettre à 0
*en lecture :
**on obtient la valeur du chronomètre
**il conviendra de multiplier la valeur lue en i2c par 8 pour obtenir la durée en ms

{{Eval|2|Ecrire un programme dans le master qui :}}
*lance le chrono
*attend 500ms
*arrête le chrono
*récupère la valeur du chrono
*affiche la valeur du chrono sur la liaison série (en ms)
*affiche la valeur du chrono sur le slave afficheur
*attend 5s avant de recommencer

=Assemblons le tout=

On réalise un jeu de réflexe : le joueur devra appuyer sur le bouton dès qu'il constate un changement sur le chenillard

{{Eval|2|Ecrire un programme correspondant à l'algorithme suivant :}}
*attendre 1s
*démarrer le chenillard
*démarrer le chrono
*attendre appui sur le bouton
*arrêter le chrono
*arrêter le chenillard
*lire le chrono
*afficher la valeur du chrono sur l'afficheur
*attendre le relâchement du bouton
*attendre 5s

Fichier:Micronucleus-cli-2.5-azd1-x86 64-linux-gnu.tar.bz2.zip

2026-04-01T08:51:09Z

Bjacquot :

Cours:Esp01

2026-03-31T06:36:55Z

Bjacquot :

<source lang=cpp>
// SP-01
// connecter GPIO0 à la masse pour programmer
// GPIO0 en l'air pour démarrer !!
// connecter CH_PD au Vcc

#include <ESP8266WiFi.h>

const char* host = "esp01DataLog";
const char* ssid = STASSID;
const char* password = STAPSK;

WiFiServer server(8080); // Port TCP

void setup(void) {
Serial.begin(921600);
Serial.println();
Serial.println("Booting Sketch...");
WiFi.mode(WIFI_STA);
WiFi.begin(ssid, password);
if (WiFi.waitForConnectResult() == WL_CONNECTED) {
Serial.println(WiFi.localIP());
server.begin();
} else {
Serial.println("WiFi Failed");
}
}

void loop(void) {
WiFiClient client = server.available();
if (client) {
while (client.connected()) {
if (Serial.available()) {
String data = Serial.readStringUntil('\n');
data.trim(); // Supprime les espaces/retours chariot
if (data.length() > 0) {
client.print(data + "\n");
//Serial.println("Envoyé: " + data); // Debug
}
}
}
client.stop();
}
}
</source>

=wifi=
on utilisera le réseau wifi :
* ssid robotGeii
* pwd robotGeiiTroyes

Cours:SaeEvitementObstacles

2026-03-31T06:24:44Z

Bjacquot :

https://docs.google.com/spreadsheets/d/1GX3zPpdC4umtqc4B8hLjQZWTMNHfw7GfKqrpxW5ORzc/edit?usp=sharing

https://www.festivalrobotiquecachan.fr/

https://www.festivalrobotiquecachan.fr/wp-content/uploads/Reglement_rencontres_de_robotique_GEII_BUT-1-2-3.pdf

=Découpage fonctionnel=

[[Media:DecoupageFcts2026.pdf]]

=Travail à réaliser=

==1ère partie (2 semaines)==
*travail individuel
**travail à réaliser pour fin de la 2ème semaine
**évaluation à la fin de la 2ème semaine (schéma/routage)
**sélection de la meilleure carte pour fabrication
***finalisation des pcbs pour le {{Rouge|jeudi 3/04 matin}}
*cartes :
**balise émettrice
***choix de la fréquence
**balise de réglage
***à l'opposé du terrain
***permet de régler l'élévation de la balise émettrice
***affiche le niveau de puissance
**carte réceptrice IR (filtre)
**carte filtrage (se plug sur la carte réceptrice IR)
***on change de carte pour changer la fréquence
**carte µc
***connectique pour e/s
***driver moteurs
***fourni alim symétrique
**banc test pour la carte filtre
**banc test pour la carte réceptrice complète

==2ème partie (xx jours)==

*Travail individuel
*montage des cartes
*vérification du fonctionnement
*réalisation programme : fonction à réaliser selon cdc

==3ème partie (xx jours)==

*travail en binôme ?
*programmation d'un robot

=Modalités d'évaluation=

==1 soutenance==
*Vendredi 17/05 matin
**20 minutes de présentation
**10 minutes de questions
*Présentation(introduction) de chaque "partie" en anglais

==1 dossier==
*Analyse fonctionnelle
*Nomenclature
*Chiffrage
*Etude détaillée de chaque fonction
*Schémas électriques/algorithmes/simulations/courbes caractéristiques/fonctions de transfert ...

==Démonstration(s)==

* Démonstration du fonctionnement le 12/05 à 12h
* Participation au festival de robotique à Cachan

==Note de résultat - Evaluation travaux de SAE==
*Groupe : accomplissement du projet
*Individuelle : en fonction de
**Difficulté technique
**Quantité de travail
**Qualité de la réalisation
**Investissement : <big>évalué chaque jour</big>

==Réalisation d'une vidéo==
Vidéo à réaliser pour le concours EEA :
https://clubeea.com/concours-mon-projet-en-5-minutes/

=Fonctions=
[[Cours:SaeEvitementObstaclesFonctions]]

=Pages indispensables du wiki=

*[[Cours:Oscillogbf|Utilisation de python et Qt pour la réalisation d'un banc de test]]
*[[Cours:PiPico|Programmation de la carte pico rp2040]]
*[[Cours:Esp01|Utilisation d'un esp-01 pour faire de la supervision]]

=Ressources informatique=

*[[Cours:pixyUartArduino|Pixy]]
*https://www.waveshare.com/wiki/RPLIDAR_C1

=Ressources=

*https://www.eeweb.com/level-shifting-techniques-in-i2c-bus-design/
*https://github.com/drankinatty/pico-mpu9250

*vérifier la "programmabilité" du µcontroleur :
**dans un terminal
**avrdude -c usbasp -p nomDuMicro
**ex : avrdude -c usbasp -p t2313
**ex : avrdude -c usbasp -p m328p

*modification des fusibles pour choisir fréquence d'horloge:
**pour les atmega328p, dans le logiciel graver le bootloader
**pour les attiny (utiliser '''arduino v1''' !! ) :
***installer attinycore : https://github.com/SpenceKonde/ATTinyCore/blob/v2.0.0-devThis-is-the-head-submit-PRs-against-this/Installation.md
***choisir le bon microcontroleur et la bonne source d'horloge
***graver la séquence d'initialisation
**pour les atmega2560, attention il faut modifier les fusibles par rapport au bootloader arduino :
***dans un terminal
***avrdude -v -patmega2560 -cusbasp -e -Ulock:w:0x3F:m -Uefuse:w:0xFD:m -Uhfuse:w:0xD9:m -Ulfuse:w:0xFF:m

*http://raphael.candelier.fr/?blog=XL_320

Cours:SaeEvitementObstacles

2026-03-30T09:33:26Z

Bjacquot :

https://docs.google.com/spreadsheets/d/1GX3zPpdC4umtqc4B8hLjQZWTMNHfw7GfKqrpxW5ORzc/edit?usp=sharing

https://www.festivalrobotiquecachan.fr/

https://www.festivalrobotiquecachan.fr/wp-content/uploads/Reglement_rencontres_de_robotique_GEII_BUT-1-2-3.pdf

=Travail à réaliser=

==1ère partie (2 semaines)==
*travail individuel
**travail à réaliser pour fin de la 2ème semaine
**évaluation à la fin de la 2ème semaine (schéma/routage)
**sélection de la meilleure carte pour fabrication
***finalisation des pcbs pour le {{Rouge|jeudi 3/04 matin}}
*cartes :
**balise émettrice
***choix de la fréquence
**balise de réglage
***à l'opposé du terrain
***permet de régler l'élévation de la balise émettrice
***affiche le niveau de puissance
**carte réceptrice IR (filtre)
**carte filtrage (se plug sur la carte réceptrice IR)
***on change de carte pour changer la fréquence
**carte µc
***connectique pour e/s
***driver moteurs
***fourni alim symétrique
**banc test pour la carte filtre
**banc test pour la carte réceptrice complète

==2ème partie (xx jours)==

*Travail individuel
*montage des cartes
*vérification du fonctionnement
*réalisation programme : fonction à réaliser selon cdc

==3ème partie (xx jours)==

*travail en binôme ?
*programmation d'un robot

=Modalités d'évaluation=

==1 soutenance==
*Vendredi 17/05 matin
**20 minutes de présentation
**10 minutes de questions
*Présentation(introduction) de chaque "partie" en anglais

==1 dossier==
*Analyse fonctionnelle
*Nomenclature
*Chiffrage
*Etude détaillée de chaque fonction
*Schémas électriques/algorithmes/simulations/courbes caractéristiques/fonctions de transfert ...

==Démonstration(s)==

* Démonstration du fonctionnement le 12/05 à 12h
* Participation au festival de robotique à Cachan

==Note de résultat - Evaluation travaux de SAE==
*Groupe : accomplissement du projet
*Individuelle : en fonction de
**Difficulté technique
**Quantité de travail
**Qualité de la réalisation
**Investissement : <big>évalué chaque jour</big>

==Réalisation d'une vidéo==
Vidéo à réaliser pour le concours EEA :
https://clubeea.com/concours-mon-projet-en-5-minutes/

=Fonctions=
[[Cours:SaeEvitementObstaclesFonctions]]

=Pages indispensables du wiki=

*[[Cours:Oscillogbf|Utilisation de python et Qt pour la réalisation d'un banc de test]]
*[[Cours:PiPico|Programmation de la carte pico rp2040]]
*[[Cours:Esp01|Utilisation d'un esp-01 pour faire de la supervision]]

=Ressources informatique=

*[[Cours:pixyUartArduino|Pixy]]
*https://www.waveshare.com/wiki/RPLIDAR_C1

=Ressources=

*https://www.eeweb.com/level-shifting-techniques-in-i2c-bus-design/
*https://github.com/drankinatty/pico-mpu9250

*vérifier la "programmabilité" du µcontroleur :
**dans un terminal
**avrdude -c usbasp -p nomDuMicro
**ex : avrdude -c usbasp -p t2313
**ex : avrdude -c usbasp -p m328p

*modification des fusibles pour choisir fréquence d'horloge:
**pour les atmega328p, dans le logiciel graver le bootloader
**pour les attiny (utiliser '''arduino v1''' !! ) :
***installer attinycore : https://github.com/SpenceKonde/ATTinyCore/blob/v2.0.0-devThis-is-the-head-submit-PRs-against-this/Installation.md
***choisir le bon microcontroleur et la bonne source d'horloge
***graver la séquence d'initialisation
**pour les atmega2560, attention il faut modifier les fusibles par rapport au bootloader arduino :
***dans un terminal
***avrdude -v -patmega2560 -cusbasp -e -Ulock:w:0x3F:m -Uefuse:w:0xFD:m -Uhfuse:w:0xD9:m -Ulfuse:w:0xFF:m

*http://raphael.candelier.fr/?blog=XL_320

Fichier:DecoupageFcts2026.pdf

2026-03-30T07:17:56Z

Bjacquot :

Cours:SaeEvitementObstacles

2026-03-30T06:37:08Z

Bjacquot :

https://www.festivalrobotiquecachan.fr/

https://www.festivalrobotiquecachan.fr/wp-content/uploads/Reglement_rencontres_de_robotique_GEII_BUT-1-2-3.pdf

=Travail à réaliser=

==1ère partie (2 semaines)==
*travail individuel
**travail à réaliser pour fin de la 2ème semaine
**évaluation à la fin de la 2ème semaine (schéma/routage)
**sélection de la meilleure carte pour fabrication
***finalisation des pcbs pour le {{Rouge|jeudi 3/04 matin}}
*cartes :
**balise émettrice
***choix de la fréquence
**balise de réglage
***à l'opposé du terrain
***permet de régler l'élévation de la balise émettrice
***affiche le niveau de puissance
**carte réceptrice IR (filtre)
**carte filtrage (se plug sur la carte réceptrice IR)
***on change de carte pour changer la fréquence
**carte µc
***connectique pour e/s
***driver moteurs
***fourni alim symétrique
**banc test pour la carte filtre
**banc test pour la carte réceptrice complète

==2ème partie (xx jours)==

*Travail individuel
*montage des cartes
*vérification du fonctionnement
*réalisation programme : fonction à réaliser selon cdc

==3ème partie (xx jours)==

*travail en binôme ?
*programmation d'un robot

=Modalités d'évaluation=

==1 soutenance==
*Vendredi 17/05 matin
**20 minutes de présentation
**10 minutes de questions
*Présentation(introduction) de chaque "partie" en anglais

==1 dossier==
*Analyse fonctionnelle
*Nomenclature
*Chiffrage
*Etude détaillée de chaque fonction
*Schémas électriques/algorithmes/simulations/courbes caractéristiques/fonctions de transfert ...

==Démonstration(s)==

* Démonstration du fonctionnement le 12/05 à 12h
* Participation au festival de robotique à Cachan

==Note de résultat - Evaluation travaux de SAE==
*Groupe : accomplissement du projet
*Individuelle : en fonction de
**Difficulté technique
**Quantité de travail
**Qualité de la réalisation
**Investissement : <big>évalué chaque jour</big>

==Réalisation d'une vidéo==
Vidéo à réaliser pour le concours EEA :
https://clubeea.com/concours-mon-projet-en-5-minutes/

=Fonctions=
[[Cours:SaeEvitementObstaclesFonctions]]

=Pages indispensables du wiki=

*[[Cours:Oscillogbf|Utilisation de python et Qt pour la réalisation d'un banc de test]]
*[[Cours:PiPico|Programmation de la carte pico rp2040]]
*[[Cours:Esp01|Utilisation d'un esp-01 pour faire de la supervision]]

=Ressources informatique=

*[[Cours:pixyUartArduino|Pixy]]
*https://www.waveshare.com/wiki/RPLIDAR_C1

=Ressources=

*https://www.eeweb.com/level-shifting-techniques-in-i2c-bus-design/
*https://github.com/drankinatty/pico-mpu9250

*vérifier la "programmabilité" du µcontroleur :
**dans un terminal
**avrdude -c usbasp -p nomDuMicro
**ex : avrdude -c usbasp -p t2313
**ex : avrdude -c usbasp -p m328p

*modification des fusibles pour choisir fréquence d'horloge:
**pour les atmega328p, dans le logiciel graver le bootloader
**pour les attiny (utiliser '''arduino v1''' !! ) :
***installer attinycore : https://github.com/SpenceKonde/ATTinyCore/blob/v2.0.0-devThis-is-the-head-submit-PRs-against-this/Installation.md
***choisir le bon microcontroleur et la bonne source d'horloge
***graver la séquence d'initialisation
**pour les atmega2560, attention il faut modifier les fusibles par rapport au bootloader arduino :
***dans un terminal
***avrdude -v -patmega2560 -cusbasp -e -Ulock:w:0x3F:m -Uefuse:w:0xFD:m -Uhfuse:w:0xD9:m -Ulfuse:w:0xFF:m

*http://raphael.candelier.fr/?blog=XL_320

Cours:SaeEvitementObstacles

2026-03-30T06:36:54Z

Bjacquot :

<---
https://docs.google.com/spreadsheets/d/1GX3zPpdC4umtqc4B8hLjQZWTMNHfw7GfKqrpxW5ORzc/edit?usp=sharing

https://docs.google.com/drawings/d/1Sx1-TMEwxtu88lV1r9OLJn0NRbNuhe1B5LcxISXYEUo/edit?usp=sharing

support de présentation : https://docs.google.com/presentation/d/1XX2BhkMtSTAADme2EaAWc-SifegQYEkAcy0RMHZ_woQ/edit?usp=sharing

fonctions informatiques : https://docs.google.com/document/d/1RmPY8mEmqChhHdfy2rKRFLjAjVSy4ZVAEw0Gml7Y8ZE/edit?tab=t.0

--->

https://www.festivalrobotiquecachan.fr/

https://www.festivalrobotiquecachan.fr/wp-content/uploads/Reglement_rencontres_de_robotique_GEII_BUT-1-2-3.pdf

=Travail à réaliser=

==1ère partie (2 semaines)==
*travail individuel
**travail à réaliser pour fin de la 2ème semaine
**évaluation à la fin de la 2ème semaine (schéma/routage)
**sélection de la meilleure carte pour fabrication
***finalisation des pcbs pour le {{Rouge|jeudi 3/04 matin}}
*cartes :
**balise émettrice
***choix de la fréquence
**balise de réglage
***à l'opposé du terrain
***permet de régler l'élévation de la balise émettrice
***affiche le niveau de puissance
**carte réceptrice IR (filtre)
**carte filtrage (se plug sur la carte réceptrice IR)
***on change de carte pour changer la fréquence
**carte µc
***connectique pour e/s
***driver moteurs
***fourni alim symétrique
**banc test pour la carte filtre
**banc test pour la carte réceptrice complète

==2ème partie (xx jours)==

*Travail individuel
*montage des cartes
*vérification du fonctionnement
*réalisation programme : fonction à réaliser selon cdc

==3ème partie (xx jours)==

*travail en binôme ?
*programmation d'un robot

=Modalités d'évaluation=

==1 soutenance==
*Vendredi 17/05 matin
**20 minutes de présentation
**10 minutes de questions
*Présentation(introduction) de chaque "partie" en anglais

==1 dossier==
*Analyse fonctionnelle
*Nomenclature
*Chiffrage
*Etude détaillée de chaque fonction
*Schémas électriques/algorithmes/simulations/courbes caractéristiques/fonctions de transfert ...

==Démonstration(s)==

* Démonstration du fonctionnement le 12/05 à 12h
* Participation au festival de robotique à Cachan

==Note de résultat - Evaluation travaux de SAE==
*Groupe : accomplissement du projet
*Individuelle : en fonction de
**Difficulté technique
**Quantité de travail
**Qualité de la réalisation
**Investissement : <big>évalué chaque jour</big>

==Réalisation d'une vidéo==
Vidéo à réaliser pour le concours EEA :
https://clubeea.com/concours-mon-projet-en-5-minutes/

=Fonctions=
[[Cours:SaeEvitementObstaclesFonctions]]

=Pages indispensables du wiki=

*[[Cours:Oscillogbf|Utilisation de python et Qt pour la réalisation d'un banc de test]]
*[[Cours:PiPico|Programmation de la carte pico rp2040]]
*[[Cours:Esp01|Utilisation d'un esp-01 pour faire de la supervision]]

=Ressources informatique=

*[[Cours:pixyUartArduino|Pixy]]
*https://www.waveshare.com/wiki/RPLIDAR_C1

=Ressources=

*https://www.eeweb.com/level-shifting-techniques-in-i2c-bus-design/
*https://github.com/drankinatty/pico-mpu9250

*vérifier la "programmabilité" du µcontroleur :
**dans un terminal
**avrdude -c usbasp -p nomDuMicro
**ex : avrdude -c usbasp -p t2313
**ex : avrdude -c usbasp -p m328p

*modification des fusibles pour choisir fréquence d'horloge:
**pour les atmega328p, dans le logiciel graver le bootloader
**pour les attiny (utiliser '''arduino v1''' !! ) :
***installer attinycore : https://github.com/SpenceKonde/ATTinyCore/blob/v2.0.0-devThis-is-the-head-submit-PRs-against-this/Installation.md
***choisir le bon microcontroleur et la bonne source d'horloge
***graver la séquence d'initialisation
**pour les atmega2560, attention il faut modifier les fusibles par rapport au bootloader arduino :
***dans un terminal
***avrdude -v -patmega2560 -cusbasp -e -Ulock:w:0x3F:m -Uefuse:w:0xFD:m -Uhfuse:w:0xD9:m -Ulfuse:w:0xFF:m

*http://raphael.candelier.fr/?blog=XL_320

Cours:InfoS2 tdI2cRegistres

2026-03-25T07:58:22Z

Bjacquot : /* Lire un registre i2c */

{{EnTeteTdInfoS2|InfoS2 tdI2cRegistres prof}}

Fichiers pour simulide : [[Media:I2cTd2.zip|I2cTd2.zip]]

{{Bleu|**************************************************}}
{{Bleu|*** Attention, programme dans un fichier .ino ***}}
{{Bleu|**************************************************}}

{{Rouge|**************************************************}}
{{Rouge|*** !!! Relier la broche Ar à la broche A+ !! ***}}
{{Rouge|**************************************************}}

=vérification des @i2c=

{{Todo|Pensez à utiliser un programme pour lister les adresses des targets i2c, cf td précédent !}}

=Registres=

Les targets i2c {{Rouge|ne sont pas}} des composants programmables. Par contre, il convient de pouvoir les {{Rouge|configurer}}.

Le principe retenu pour la plupart des targets est d'utiliser la notion de {{Rouge|registres}}.
*1 registre est une {{Rouge|mémoire}} sur la cible
*1 registre est associé à {{Rouge|une adresse}}
*chaque registre {{Rouge|modifie/observe}} le fonctionnement de la target
*1 registre à {{Rouge|un rôle spécifique}}
*pour {{Rouge|utiliser}} le composant, il faut indiquer {{Rouge|l'adresse}} du registre, que l'on souhaite {{Rouge|lire ou écrire}}

[[fichier:I2c_modele.png|600px]]

Une {{Rouge|transmission}} i2c devient alors une {{Rouge|trame}} selon le principe simplifié suivant :
*bit de start
*@ de la target (7 bits)
*bit de lecture/écriture
*{{Rouge|attente de l'acknowledge}} (accusé de bonne réception) de la cible
*choix d'un registre (8 bits)
*acknowledge
*envoi/réception de la valeur (8 bits)
*acknowledge
*bit de stop

=Ecrire dans un registre i2c=

Voici un programme d'exemple pour modifier la valeur d'un registre :

<source lang=cpp>
#include <Wire.h>
const uint8_t targetAdress=0x04;
uint8_t regAd=7;
uint8_t value=0b10101010;

int main()
{
Wire.begin(); // join i2c bus (address optional for master)
Serial.begin(9600);
sei();
while(1)
{
Wire.beginTransmission(targetAdress); // start transmitting
Wire.write(regAd); // sends @ registre
Wire.write(value); // sends value registre
Wire.endTransmission(); // stop transmitting
}
}
</source>

Nous considérons ici la cible avec les leds.

Cette target i2c possède 6 registres d'adresses 0 à 5.

Chaque registre est une valeur [0 255], qui modifie l'intensité lumineuse d'une led.

{{Question|Ecrire un programme permettant de faire varier l'intensité lumineuse d'une, puis de plusieurs, leds}}

{Question|Ecrire une fonction qui permet de modifier la valeur d'un registre d'une cible en respectant la signature suivante: }}
void writeI2cReg(uint8_t targetAddress, uint8_t regAddress, uint8_t regValue)

=Lire un registre i2c=

Voici un programme d'exemple pour lire la valeur d'un registre :

<source lang=cpp>
#include <Wire.h>
const uint8_t targetAdress=0x04;
uint8_t regAd=5;
uint8_t value=60;

int main()
{
Wire.begin(); // join i2c bus (address optional for master)
Serial.begin(9600);
sei();
while(1)
{
Wire.beginTransmission(targetAdress); // start transmitting
Wire.write(regAd); // sends @ registre
Wire.endTransmission(); // stop transmitting
Wire.requestFrom(targetAdress, (uint8_t) 1);
value = Wire.read();
Serial.println(value);
}
}
</source>

Nous considérons ici la cible avec les potentiomètres.

Cette target i2c possède 4 registres d'adresses 0 à 3.

Chaque registre est une valeur [0 255], qui varie en fonction de la position du potentiomètre.

{{Question|Ecrire un programme permettant de lire les valeurs des potentiomètres}}

{{Question|Ecrire une fonction qui permet de modifier la valeur d'un registre d'une cible en respectant la signature suivante: }}
uint8_t readI2cReg(uint8_t targetAddress, uint8_t regAddress)

=Association=

{{Question|Faire en sorte que chaque potentiomètre modifie l'intensité lumineuse d'une led différente}}

Cours:InfoS2 tdI2cRegistres

2026-03-24T22:19:19Z

Bjacquot :

{{EnTeteTdInfoS2|InfoS2 tdI2cRegistres prof}}

Fichiers pour simulide : [[Media:I2cTd2.zip|I2cTd2.zip]]

{{Bleu|**************************************************}}
{{Bleu|*** Attention, programme dans un fichier .ino ***}}
{{Bleu|**************************************************}}

{{Rouge|**************************************************}}
{{Rouge|*** !!! Relier la broche Ar à la broche A+ !! ***}}
{{Rouge|**************************************************}}

=vérification des @i2c=

{{Todo|Pensez à utiliser un programme pour lister les adresses des targets i2c, cf td précédent !}}

=Registres=

Les targets i2c {{Rouge|ne sont pas}} des composants programmables. Par contre, il convient de pouvoir les {{Rouge|configurer}}.

Le principe retenu pour la plupart des targets est d'utiliser la notion de {{Rouge|registres}}.
*1 registre est une {{Rouge|mémoire}} sur la cible
*1 registre est associé à {{Rouge|une adresse}}
*chaque registre {{Rouge|modifie/observe}} le fonctionnement de la target
*1 registre à {{Rouge|un rôle spécifique}}
*pour {{Rouge|utiliser}} le composant, il faut indiquer {{Rouge|l'adresse}} du registre, que l'on souhaite {{Rouge|lire ou écrire}}

[[fichier:I2c_modele.png|600px]]

Une {{Rouge|transmission}} i2c devient alors une {{Rouge|trame}} selon le principe simplifié suivant :
*bit de start
*@ de la target (7 bits)
*bit de lecture/écriture
*{{Rouge|attente de l'acknowledge}} (accusé de bonne réception) de la cible
*choix d'un registre (8 bits)
*acknowledge
*envoi/réception de la valeur (8 bits)
*acknowledge
*bit de stop

=Ecrire dans un registre i2c=

Voici un programme d'exemple pour modifier la valeur d'un registre :

<source lang=cpp>
#include <Wire.h>
const uint8_t targetAdress=0x04;
uint8_t regAd=7;
uint8_t value=0b10101010;

int main()
{
Wire.begin(); // join i2c bus (address optional for master)
Serial.begin(9600);
sei();
while(1)
{
Wire.beginTransmission(targetAdress); // start transmitting
Wire.write(regAd); // sends @ registre
Wire.write(value); // sends value registre
Wire.endTransmission(); // stop transmitting
}
}
</source>

Nous considérons ici la cible avec les leds.

Cette target i2c possède 6 registres d'adresses 0 à 5.

Chaque registre est une valeur [0 255], qui modifie l'intensité lumineuse d'une led.

{{Question|Ecrire un programme permettant de faire varier l'intensité lumineuse d'une, puis de plusieurs, leds}}

{Question|Ecrire une fonction qui permet de modifier la valeur d'un registre d'une cible en respectant la signature suivante: }}
void writeI2cReg(uint8_t targetAddress, uint8_t regAddress, uint8_t regValue)

=Lire un registre i2c=

Voici un programme d'exemple pour lire la valeur d'un registre :

<source lang=cpp>
#include <Wire.h>
const uint8_t targetAdress=0x04;
uint8_t regAd=5;
uint8_t value=60;

int main()
{
Wire.begin(); // join i2c bus (address optional for master)
Serial.begin(9600);
sei();
while(1)
{
Wire.beginTransmission(targetAdress); // start transmitting
Wire.write(regAd); // sends @ registre
Wire.endTransmission(); // stop transmitting
Wire.requestFrom(targetAdress, (uint8_t) 1);
value = Wire.read();
Serial.println(value);
}
}
</source>

Nous considérons ici la cible avec les potentiomètres.

Cette target i2c possède 4 registres d'adresses 0 à 3.

Chaque registre est une valeur [0 255], qui varie en fonction de la position du potentiomètre.

{{Question|Ecrire un programme permettant de lire les valeurs des potentiomètres}}

{Question|Ecrire une fonction qui permet de modifier la valeur d'un registre d'une cible en respectant la signature suivante: }}
uint8_t readI2cReg(uint8_t targetAddress, uint8_t regAddress)

=Association=

{{Question|Faire en sorte que chaque potentiomètre modifie l'intensité lumineuse d'une led différente}}

Cours:InfoS2 tdI2cRegistres

2026-03-24T21:51:01Z

Bjacquot : /* Lire un registre i2c */

{{EnTeteTdInfoS2|InfoS2 tdI2cRegistres prof}}

Fichiers pour simulide : [[Media:I2cTd2.zip|I2cTd2.zip]]

{{Rouge|**************************************************}}
{{Rouge|*** Attention, programme dans un fichier .ino ***}}
{{Rouge|**************************************************}}

=vérification des @i2c=

{{Todo|Pensez à utiliser un programme pour lister les adresses des targets i2c, cf td précédent !}}

=Registres=

Les targets i2c {{Rouge|ne sont pas}} des composants programmables. Par contre, il convient de pouvoir les {{Rouge|configurer}}.

Le principe retenu pour la plupart des targets est d'utiliser la notion de {{Rouge|registres}}.
*1 registre est une {{Rouge|mémoire}} sur la cible
*1 registre est associé à {{Rouge|une adresse}}
*chaque registre {{Rouge|modifie/observe}} le fonctionnement de la target
*1 registre à {{Rouge|un rôle spécifique}}
*pour {{Rouge|utiliser}} le composant, il faut indiquer {{Rouge|l'adresse}} du registre, que l'on souhaite {{Rouge|lire ou écrire}}

[[fichier:I2c_modele.png|600px]]

Une {{Rouge|transmission}} i2c devient alors une {{Rouge|trame}} selon le principe simplifié suivant :
*bit de start
*@ de la target (7 bits)
*bit de lecture/écriture
*{{Rouge|attente de l'acknowledge}} (accusé de bonne réception) de la cible
*choix d'un registre (8 bits)
*acknowledge
*envoi/réception de la valeur (8 bits)
*acknowledge
*bit de stop

=Ecrire dans un registre i2c=

Voici un programme d'exemple pour modifier la valeur d'un registre :

<source lang=cpp>
#include <Wire.h>
const uint8_t targetAdress=0x04;
uint8_t regAd=7;
uint8_t value=0b10101010;

int main()
{
Wire.begin(); // join i2c bus (address optional for master)
Serial.begin(9600);
sei();
while(1)
{
Wire.beginTransmission(targetAdress); // start transmitting
Wire.write(regAd); // sends @ registre
Wire.write(value); // sends value registre
Wire.endTransmission(); // stop transmitting
}
}
</source>

Nous considérons ici la cible avec les leds.

Cette target i2c possède 6 registres d'adresses 0 à 5.

Chaque registre est une valeur [0 255], qui modifie l'intensité lumineuse d'une led.

{{Question|Ecrire un programme permettant de faire varier l'intensité lumineuse d'une, puis de plusieurs, leds}}

{Question|Ecrire une fonction qui permet de modifier la valeur d'un registre d'une cible en respectant la signature suivante: }}
void writeI2cReg(uint8_t targetAddress, uint8_t regAddress, uint8_t regValue)

=Lire un registre i2c=

Voici un programme d'exemple pour lire la valeur d'un registre :

<source lang=cpp>
#include <Wire.h>
const uint8_t targetAdress=0x04;
uint8_t regAd=5;
uint8_t value=60;

int main()
{
Wire.begin(); // join i2c bus (address optional for master)
Serial.begin(9600);
sei();
while(1)
{
Wire.beginTransmission(targetAdress); // start transmitting
Wire.write(regAd); // sends @ registre
Wire.endTransmission(); // stop transmitting
Wire.requestFrom(targetAdress, (uint8_t) 1);
value = Wire.read();
Serial.println(value);
}
}
</source>

Nous considérons ici la cible avec les potentiomètres.

Cette target i2c possède 4 registres d'adresses 0 à 3.

Chaque registre est une valeur [0 255], qui varie en fonction de la position du potentiomètre.

{{Question|Ecrire un programme permettant de lire les valeurs des potentiomètres}}

{Question|Ecrire une fonction qui permet de modifier la valeur d'un registre d'une cible en respectant la signature suivante: }}
uint8_t readI2cReg(uint8_t targetAddress, uint8_t regAddress)

=Association=

{{Question|Faire en sorte que chaque potentiomètre modifie l'intensité lumineuse d'une led différente}}

Cours:InfoS2 tdI2cRegistres

2026-03-24T21:38:46Z

Bjacquot : /* Lire un registre i2c */

{{EnTeteTdInfoS2|InfoS2 tdI2cRegistres prof}}

Fichiers pour simulide : [[Media:I2cTd2.zip|I2cTd2.zip]]

{{Rouge|**************************************************}}
{{Rouge|*** Attention, programme dans un fichier .ino ***}}
{{Rouge|**************************************************}}

=vérification des @i2c=

{{Todo|Pensez à utiliser un programme pour lister les adresses des targets i2c, cf td précédent !}}

=Registres=

Les targets i2c {{Rouge|ne sont pas}} des composants programmables. Par contre, il convient de pouvoir les {{Rouge|configurer}}.

Le principe retenu pour la plupart des targets est d'utiliser la notion de {{Rouge|registres}}.
*1 registre est une {{Rouge|mémoire}} sur la cible
*1 registre est associé à {{Rouge|une adresse}}
*chaque registre {{Rouge|modifie/observe}} le fonctionnement de la target
*1 registre à {{Rouge|un rôle spécifique}}
*pour {{Rouge|utiliser}} le composant, il faut indiquer {{Rouge|l'adresse}} du registre, que l'on souhaite {{Rouge|lire ou écrire}}

[[fichier:I2c_modele.png|600px]]

Une {{Rouge|transmission}} i2c devient alors une {{Rouge|trame}} selon le principe simplifié suivant :
*bit de start
*@ de la target (7 bits)
*bit de lecture/écriture
*{{Rouge|attente de l'acknowledge}} (accusé de bonne réception) de la cible
*choix d'un registre (8 bits)
*acknowledge
*envoi/réception de la valeur (8 bits)
*acknowledge
*bit de stop

=Ecrire dans un registre i2c=

Voici un programme d'exemple pour modifier la valeur d'un registre :

<source lang=cpp>
#include <Wire.h>
const uint8_t targetAdress=0x04;
uint8_t regAd=7;
uint8_t value=0b10101010;

int main()
{
Wire.begin(); // join i2c bus (address optional for master)
Serial.begin(9600);
sei();
while(1)
{
Wire.beginTransmission(targetAdress); // start transmitting
Wire.write(regAd); // sends @ registre
Wire.write(value); // sends value registre
Wire.endTransmission(); // stop transmitting
}
}
</source>

Nous considérons ici la cible avec les leds.

Cette target i2c possède 6 registres d'adresses 0 à 5.

Chaque registre est une valeur [0 255], qui modifie l'intensité lumineuse d'une led.

{{Question|Ecrire un programme permettant de faire varier l'intensité lumineuse d'une, puis de plusieurs, leds}}

{Question|Ecrire une fonction qui permet de modifier la valeur d'un registre d'une cible en respectant la signature suivante: }}
void writeI2cReg(uint8_t targetAddress, uint8_t regAddress, uint8_t regValue)

=Lire un registre i2c=

Voici un programme d'exemple pour lire la valeur d'un registre :

<source lang=cpp>
#include <Wire.h>
const uint8_t targetAdress=0x04;
uint8_t regAd=5;
uint8_t value=60;

int main()
{
Wire.begin(); // join i2c bus (address optional for master)
Serial.begin(9600);
sei();
while(1)
{
Wire.beginTransmission(targetAdress); // start transmitting
Wire.write(regAd); // sends @ registre
Wire.endTransmission(); // stop transmitting
Wire.requestFrom(targetAdress, 1);
value = Wire.read();
Serial.println(value);
}
}
</source>

Nous considérons ici la cible avec les potentiomètres.

Cette target i2c possède 4 registres d'adresses 0 à 3.

Chaque registre est une valeur [0 255], qui varie en fonction de la position du potentiomètre.

{{Question|Ecrire un programme permettant de lire les valeurs des potentiomètres}}

{Question|Ecrire une fonction qui permet de modifier la valeur d'un registre d'une cible en respectant la signature suivante: }}
uint8_t readI2cReg(uint8_t targetAddress, uint8_t regAddress)

=Association=

{{Question|Faire en sorte que chaque potentiomètre modifie l'intensité lumineuse d'une led différente}}

Cours:InfoS2 tdI2cRegistres

2026-03-24T21:37:57Z

Bjacquot : /* Ecrire dans un registre i2c */

{{EnTeteTdInfoS2|InfoS2 tdI2cRegistres prof}}

Fichiers pour simulide : [[Media:I2cTd2.zip|I2cTd2.zip]]

{{Rouge|**************************************************}}
{{Rouge|*** Attention, programme dans un fichier .ino ***}}
{{Rouge|**************************************************}}

=vérification des @i2c=

{{Todo|Pensez à utiliser un programme pour lister les adresses des targets i2c, cf td précédent !}}

=Registres=

Les targets i2c {{Rouge|ne sont pas}} des composants programmables. Par contre, il convient de pouvoir les {{Rouge|configurer}}.

Le principe retenu pour la plupart des targets est d'utiliser la notion de {{Rouge|registres}}.
*1 registre est une {{Rouge|mémoire}} sur la cible
*1 registre est associé à {{Rouge|une adresse}}
*chaque registre {{Rouge|modifie/observe}} le fonctionnement de la target
*1 registre à {{Rouge|un rôle spécifique}}
*pour {{Rouge|utiliser}} le composant, il faut indiquer {{Rouge|l'adresse}} du registre, que l'on souhaite {{Rouge|lire ou écrire}}

[[fichier:I2c_modele.png|600px]]

Une {{Rouge|transmission}} i2c devient alors une {{Rouge|trame}} selon le principe simplifié suivant :
*bit de start
*@ de la target (7 bits)
*bit de lecture/écriture
*{{Rouge|attente de l'acknowledge}} (accusé de bonne réception) de la cible
*choix d'un registre (8 bits)
*acknowledge
*envoi/réception de la valeur (8 bits)
*acknowledge
*bit de stop

=Ecrire dans un registre i2c=

Voici un programme d'exemple pour modifier la valeur d'un registre :

<source lang=cpp>
#include <Wire.h>
const uint8_t targetAdress=0x04;
uint8_t regAd=7;
uint8_t value=0b10101010;

int main()
{
Wire.begin(); // join i2c bus (address optional for master)
Serial.begin(9600);
sei();
while(1)
{
Wire.beginTransmission(targetAdress); // start transmitting
Wire.write(regAd); // sends @ registre
Wire.write(value); // sends value registre
Wire.endTransmission(); // stop transmitting
}
}
</source>

Nous considérons ici la cible avec les leds.

Cette target i2c possède 6 registres d'adresses 0 à 5.

Chaque registre est une valeur [0 255], qui modifie l'intensité lumineuse d'une led.

{{Question|Ecrire un programme permettant de faire varier l'intensité lumineuse d'une, puis de plusieurs, leds}}

{Question|Ecrire une fonction qui permet de modifier la valeur d'un registre d'une cible en respectant la signature suivante: }}
void writeI2cReg(uint8_t targetAddress, uint8_t regAddress, uint8_t regValue)

=Lire un registre i2c=

Voici un programme d'exemple pour lire la valeur d'un registre :

<source lang=cpp>
#include <Wire.h>
const uint8_t targetAdress=0x04;
uint8_t regAd=5;
uint8_t value=60;

int main()
{
Wire.begin(); // join i2c bus (address optional for master)
Serial.begin(9600);
sei();
while(1)
{
Wire.beginTransmission(targetAdress); // start transmitting
Wire.write(regAd); // sends @ registre
Wire.endTransmission(); // stop transmitting
Wire.requestFrom(targetAdress, 1);
while (Wire.available()) value = Wire.read();
Serial.println(value);
}
}
</source>

Nous considérons ici la cible avec les potentiomètres.

Cette target i2c possède 4 registres d'adresses 0 à 3.

Chaque registre est une valeur [0 255], qui varie en fonction de la position du potentiomètre.

{{Question|Ecrire un programme permettant de lire les valeurs des potentiomètres}}

=Association=

{{Question|Faire en sorte que chaque potentiomètre modifie l'intensité lumineuse d'une led différente}}

Cours:TPS 2103 tp regulationVitesse

2026-03-16T09:52:08Z

Bjacquot : /* Contraintes */

<accesscontrol>Acces:Prof</accesscontrol>

=Contraintes=
*pour contrôler la vitesse du moteur :
**on utilisera un timer 16 bits (timer1)
**utilisation du timer1 dans le mode 14
*un potentiomètre sera utilisé en le reliant sur la broche indiquée ci-dessous
*vous respecterez les contraintes spécifiques suivantes :
{| class="wikitable"
|-
! Groupe TP !! sujet !! sortie du timer !! valeur max(top) du timer1 !! valeurs de rapport cyclique !! prédiviseur !! entrée potar !! nombre d'incréments / 10ms
|-
| 1A || A || OC1A || 3199 || 20% / 60% || 8 || ADC3 || 9
|-
| 1A || B || OC1A || 15999 || 10% / 90% || 1 || ADC2 || 7
|-
| 1B || A || OC1B || 3899 || 25% / 75% || 8 || ADC5 || 8
|-
| 1B || B || OC1B || 24999 || 40% / 60% || 1 || ADC4 || 9
|-
| 2A || A || OC1A || 2399 || 25% / 50% || 8 || ADC3 || 6
|-
| 2A || B || OC1A || 17999 || 30% / 70% || 1 || ADC1 || 7
|-
| 2B || A || OC1B || 2499 || 25% / 50% || 8 || ADC2 || 9
|-
| 2B || B || OC1B || 16999 || 40% / 75% || 1 || ADC3 || 6
|}

=Travail à réaliser=

==mode marche/arrêt==

on utilise le bouton BP1 comme bouton '''marche''' :
le moteur ne pourra tourner que si on maintient le bouton marche appuyé

{{Eval|2|Visualisation du mode de fonctionnement avec 2 leds}}
*entrées/sorties
**relier le bouton sur la broche PD2
**relier la led rouge sur PD6
**relier la led verte sur PD7
*bouton est appuyé
**mode marche
**led verte allumée
*bouton n'est pas appuyé
**mode arrêt
**led rouge allumée

==génération de MLI==

Vous allez générer une MLI qui permettra de faire varier la vitesse de rotation du moteur.

Vous trouverez dans le tableau les contraintes (sortie du timer/ valeur Top / prédiviseur/valeurs de rapport cyclique)

{{Eval|4|génération et vérification de la MLI }}
*utilisation du Timer 1 (16 bits)
*en mode 14
*avec la valeur Top indiquée dans le tableau
*avec le prédiviseur indiqué dans le tableau
*faire varier le rapport cyclique :
**alterner entre les 2 valeur de rapport cyclique du tableau
**en changeant toutes les 5 secondes
*visualiser la MLI à l'oscilloscope

{{Eval|2|banchez le moteur et faire en sorte que}}
*en mode arrêt le moteur ne tourne pas (bouton relâché/led rouge allumée)
*en mode marche : le moteur change de vitesse selon les 2 valeurs de rapport cyclique toutes les 5 secondes

==Asservissement de vitesse==
On utilise des fourches optiques [https://fr.farnell.com/vishay/tcut1300x01/capteur-transm-aec-q101-1-2v-cms/dp/2889654?st=TCUT1300X01 TCUT1300] pour détecter la rotation de l'arbre moteur.

Il y a 8 dents sur la roue codeuse par tour.

On utilisera l'entrée INT1 pour réaliser le comptage de la roue codeuse.

<source lang=cpp>
//interruption qui incrémente un compteur à chaque front montant de la fourche optique

int main()
{
// configuration dont timer/interruption
while(1)
{
_delay_ms(10);
// ttes les 10ms on :
// regarde la valeur du compteur de la fourche optique
// augmente/diminue la vitesse si le compteur est sup/inf à 8
// remettre à 0 le compteur
}
}
</source>

{{Eval|5|Asservir la vitesse de rotation de l'arbre moteur pour avoir le bon nombre d'incréments toutes les 10ms :}}
'''Prendre la valeur demandée dans le tableau partie contraintes'''

Remarque : Il suffit de diminuer(d'augmenter) le rapport cyclique si il y a trop (pas assez) d'impulsions dans le temps imparti.

{{Eval|1|En déduire la vitesse de rotation en sortie de réducteur, et vérifier avec un tachymètre}}

==modification de la vitesse de consigne==

On va utiliser le potentiomètre pour modifier la valeur de consigne (nombre d'incréments/10ms)

{{Eval|4|Ajouter la gestion du potentiomètre}}
*connecter le potentiomètre sur l'entrée indiquée dans le tableau
*configurer l'ADC
*faire varier le nombre d'incréments de 4 à 12 lorsque le potentiomètre tourne de part en part.

'''Remarque''' : vous pouvez utiliser la liaison série pour mettre au point :
<source lang=c>
int main()
{
sei();
Serial.begin(9600);
while(1)
{
Serial.println("top");
_delay_ms(500);
}
}
</source>

==comptage avec un Timer==
Il est possible de décharger le processeur de la tâche de comptage en utilisant un Timer.

On utilisera le timer0 qu'on configurera :
*en mode normal
*entrée d'horloge sur T0 (choix avec les bits CS02/CS01/CS00)
*la valeur du compteur correspond au registre TCNT0

{{Eval|2|Modifier votre programme en conséquence}}

'''<big>Remarques :</big>'''
*en observant les fronts montants+descendants il y a 16 impulsions par tour, ce qui permet d'augmenter la précision de la mesure de vitesse
*on peut jouer sur la durée du delay
**il faut rester dans les limites du compteur (8 bits)
**on peut éventuellement observer le bit de débordement du timer