troyesGEII - Contributions de l’utilisateur [fr]

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

Cours:TPS 2103 tp regulationVitesse

2026-03-12T10:25:38Z

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 || 3069 || 20% / 60% || 8 || ADC3 || 9
|-
| 1A || B || OC1A || 3069 || 10% / 90% || 8 || ADC2 || 7
|-
| 1B || A || OC1B || 5115 || 25% / 75% || 1 || ADC5 || 8
|-
| 1B || B || OC1B || 5115 || 40% / 60% || 1 || ADC4 || 9
|-
| 2A || A || OC1A || 4092 || 25% / 50% || 8 || ADC3 || 6
|-
| 2A || B || OC1A || 4092 || 30% / 70% || 8 || ADC1 || 7
|-
| 2B || A || OC1B || 6138 || 25% / 50% || 1 || ADC2 || 9
|-
| 2B || B || OC1B || 6138 || 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

Cours:TPS 2103 tp regulationVitesse

2026-03-12T10:24:43Z

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 || 3069 || 20% / 60% || 8 || ADC2 || 9
|-
| 1A || B || OC1A || 3069 || 10% / 90% || 8 || ADC2 || 7
|-
| 1B || A || OC1B || 5115 || 25% / 75% || 1 || ADC4 || 8
|-
| 1B || B || OC1B || 5115 || 40% / 60% || 1 || ADC4 || 9
|-
| 2A || A || OC1A || 4092 || 25% / 50% || 8 || ADC1 || 6
|-
| 2A || B || OC1A || 4092 || 30% / 70% || 8 || ADC1 || 7
|-
| 2B || A || OC1B || 6138 || 25% / 50% || 1 || ADC3 || 9
|-
| 2B || B || OC1B || 6138 || 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

Cours:TPS 2103 tp regulationVitesse

2026-03-12T10:24:16Z

Bjacquot : /* génération de MLI */

<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 || 3069 || 20% / 60% || 8 || ADC2 || 9
|-
| 1A || B || OC1A || 3069 || 10% / 90% || 8 || ADC2 || 9
|-
| 1B || A || OC1B || 5115 || 25% / 75% || 1 || ADC4 || 8
|-
| 1B || B || OC1B || 5115 || 40% / 60% || 1 || ADC4 || 8
|-
| 2A || A || OC1A || 4092 || 25% / 50% || 8 || ADC1 || 7
|-
| 2A || B || OC1A || 4092 || 30% / 70% || 8 || ADC1 || 7
|-
| 2B || A || OC1B || 6138 || 25% / 50% || 1 || ADC3 || 6
|-
| 2B || B || OC1B || 6138 || 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

Cours:TPS 2103 tp regulationVitesse

2026-03-12T10:23:37Z

Bjacquot : /* modification de la vitesse de consigne */

<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 || 3069 || 20% / 60% || 8 || ADC2 || 9
|-
| 1A || B || OC1A || 3069 || 10% / 90% || 8 || ADC2 || 9
|-
| 1B || A || OC1B || 5115 || 25% / 75% || 1 || ADC4 || 8
|-
| 1B || B || OC1B || 5115 || 40% / 60% || 1 || ADC4 || 8
|-
| 2A || A || OC1A || 4092 || 25% / 50% || 8 || ADC1 || 7
|-
| 2A || B || OC1A || 4092 || 30% / 70% || 8 || ADC1 || 7
|-
| 2B || A || OC1B || 6138 || 25% / 50% || 1 || ADC3 || 6
|-
| 2B || B || OC1B || 6138 || 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|5|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

Cours:TPS 2103 tp regulationVitesse

2026-03-12T10:22:59Z

Bjacquot : /* modification de la vitesse de consigne */

<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 || 3069 || 20% / 60% || 8 || ADC2 || 9
|-
| 1A || B || OC1A || 3069 || 10% / 90% || 8 || ADC2 || 9
|-
| 1B || A || OC1B || 5115 || 25% / 75% || 1 || ADC4 || 8
|-
| 1B || B || OC1B || 5115 || 40% / 60% || 1 || ADC4 || 8
|-
| 2A || A || OC1A || 4092 || 25% / 50% || 8 || ADC1 || 7
|-
| 2A || B || OC1A || 4092 || 30% / 70% || 8 || ADC1 || 7
|-
| 2B || A || OC1B || 6138 || 25% / 50% || 1 || ADC3 || 6
|-
| 2B || B || OC1B || 6138 || 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|5|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.

<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

Cours:TPS 2103 tp regulationVitesse

2026-03-12T10:13:11Z

Bjacquot : /* Asservissement de vitesse */

<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 || 3069 || 20% / 60% || 8 || ADC2 || 9
|-
| 1A || B || OC1A || 3069 || 10% / 90% || 8 || ADC2 || 9
|-
| 1B || A || OC1B || 5115 || 25% / 75% || 1 || ADC4 || 8
|-
| 1B || B || OC1B || 5115 || 40% / 60% || 1 || ADC4 || 8
|-
| 2A || A || OC1A || 4092 || 25% / 50% || 8 || ADC1 || 7
|-
| 2A || B || OC1A || 4092 || 30% / 70% || 8 || ADC1 || 7
|-
| 2B || A || OC1B || 6138 || 25% / 50% || 1 || ADC3 || 6
|-
| 2B || B || OC1B || 6138 || 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|5|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==

==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

Cours:TPS 2103 tp regulationVitesse

2026-03-12T10:10:22Z

Bjacquot : /* Asservissement de vitesse */

<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 || 3069 || 20% / 60% || 8 || ADC2 || 9
|-
| 1A || B || OC1A || 3069 || 10% / 90% || 8 || ADC2 || 9
|-
| 1B || A || OC1B || 5115 || 25% / 75% || 1 || ADC4 || 8
|-
| 1B || B || OC1B || 5115 || 40% / 60% || 1 || ADC4 || 8
|-
| 2A || A || OC1A || 4092 || 25% / 50% || 8 || ADC1 || 7
|-
| 2A || B || OC1A || 4092 || 30% / 70% || 8 || ADC1 || 7
|-
| 2B || A || OC1B || 6138 || 25% / 50% || 1 || ADC3 || 6
|-
| 2B || B || OC1B || 6138 || 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|5|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 d'augmenter(diminuer) 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==

==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

Cours:TPS 2103 tp regulationVitesse

2026-03-12T09:47:27Z

Bjacquot : /* Mise en marche/arrêt */

<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 || 3069 || 20% / 60% || 8 || ADC2 || 9
|-
| 1A || B || OC1A || 3069 || 10% / 90% || 8 || ADC2 || 9
|-
| 1B || A || OC1B || 5115 || 25% / 75% || 1 || ADC4 || 8
|-
| 1B || B || OC1B || 5115 || 40% / 60% || 1 || ADC4 || 8
|-
| 2A || A || OC1A || 4092 || 25% / 50% || 8 || ADC1 || 7
|-
| 2A || B || OC1A || 4092 || 30% / 70% || 8 || ADC1 || 7
|-
| 2B || A || OC1B || 6138 || 25% / 50% || 1 || ADC3 || 6
|-
| 2B || B || OC1B || 6138 || 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|5|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 d'augmenter(diminuer) 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}}

==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

Cours:TPS 2103 tp regulationVitesse

2026-03-12T09:45:08Z

Bjacquot : /* génération de MLI */

<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 || 3069 || 20% / 60% || 8 || ADC2 || 9
|-
| 1A || B || OC1A || 3069 || 10% / 90% || 8 || ADC2 || 9
|-
| 1B || A || OC1B || 5115 || 25% / 75% || 1 || ADC4 || 8
|-
| 1B || B || OC1B || 5115 || 40% / 60% || 1 || ADC4 || 8
|-
| 2A || A || OC1A || 4092 || 25% / 50% || 8 || ADC1 || 7
|-
| 2A || B || OC1A || 4092 || 30% / 70% || 8 || ADC1 || 7
|-
| 2B || A || OC1B || 6138 || 25% / 50% || 1 || ADC3 || 6
|-
| 2B || B || OC1B || 6138 || 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|5|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 d'augmenter(diminuer) 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}}

==Mise en marche/arrêt==
{{Eval|2|Ajouter la gestion marche/arrêt avec un 1 bouton poussoir qui sera connecté sur la broche PD2 :}}

'''Vous devez utiliser une interruption pour réaliser cette fonction'''

*au 1er appui on met en route le moteur
*à l'appui suivant il s'arrête
*il n'y a pas besoin de maintenir le bouton pour que le moteur tourne
*on conserve le potentiomètre pour modifier la vitesse

<big>'''Attention'''</big>, le rapport cyclique n'est jamais nul, pour arrêter le moteur
*déconnecter la broche du timer ( bits COMxxx)
*mettre la sortie à 0

==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

Cours:TPS 2103 tp regulationVitesse

2026-03-12T09:43:04Z

Bjacquot : /* mode marche/arrêt */

<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 || 3069 || 20% / 60% || 8 || ADC2 || 9
|-
| 1A || B || OC1A || 3069 || 10% / 90% || 8 || ADC2 || 9
|-
| 1B || A || OC1B || 5115 || 25% / 75% || 1 || ADC4 || 8
|-
| 1B || B || OC1B || 5115 || 40% / 60% || 1 || ADC4 || 8
|-
| 2A || A || OC1A || 4092 || 25% / 50% || 8 || ADC1 || 7
|-
| 2A || B || OC1A || 4092 || 30% / 70% || 8 || ADC1 || 7
|-
| 2B || A || OC1B || 6138 || 25% / 50% || 1 || ADC3 || 6
|-
| 2B || B || OC1B || 6138 || 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|5|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|1|vous pouvez brancher le moteur et valider le fonctionnement}}

==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 d'augmenter(diminuer) 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}}

==Mise en marche/arrêt==
{{Eval|2|Ajouter la gestion marche/arrêt avec un 1 bouton poussoir qui sera connecté sur la broche PD2 :}}

'''Vous devez utiliser une interruption pour réaliser cette fonction'''

*au 1er appui on met en route le moteur
*à l'appui suivant il s'arrête
*il n'y a pas besoin de maintenir le bouton pour que le moteur tourne
*on conserve le potentiomètre pour modifier la vitesse

<big>'''Attention'''</big>, le rapport cyclique n'est jamais nul, pour arrêter le moteur
*déconnecter la broche du timer ( bits COMxxx)
*mettre la sortie à 0

==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

Cours:TPS 2103 tp regulationVitesse

2026-03-12T09:42:14Z

Bjacquot : /* Travail à réaliser */

<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 || 3069 || 20% / 60% || 8 || ADC2 || 9
|-
| 1A || B || OC1A || 3069 || 10% / 90% || 8 || ADC2 || 9
|-
| 1B || A || OC1B || 5115 || 25% / 75% || 1 || ADC4 || 8
|-
| 1B || B || OC1B || 5115 || 40% / 60% || 1 || ADC4 || 8
|-
| 2A || A || OC1A || 4092 || 25% / 50% || 8 || ADC1 || 7
|-
| 2A || B || OC1A || 4092 || 30% / 70% || 8 || ADC1 || 7
|-
| 2B || A || OC1B || 6138 || 25% / 50% || 1 || ADC3 || 6
|-
| 2B || B || OC1B || 6138 || 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
*on est en mode marche si le bouton est appuyé => led verte allumée
*on est en mode arrêt si le bouton n'est pas appuyé => 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|5|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|1|vous pouvez brancher le moteur et valider le fonctionnement}}

==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 d'augmenter(diminuer) 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}}

==Mise en marche/arrêt==
{{Eval|2|Ajouter la gestion marche/arrêt avec un 1 bouton poussoir qui sera connecté sur la broche PD2 :}}

'''Vous devez utiliser une interruption pour réaliser cette fonction'''

*au 1er appui on met en route le moteur
*à l'appui suivant il s'arrête
*il n'y a pas besoin de maintenir le bouton pour que le moteur tourne
*on conserve le potentiomètre pour modifier la vitesse

<big>'''Attention'''</big>, le rapport cyclique n'est jamais nul, pour arrêter le moteur
*déconnecter la broche du timer ( bits COMxxx)
*mettre la sortie à 0

==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

Cours:TPS 2103 tp regulationVitesse

2026-03-12T09:22:15Z

Bjacquot :

<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 || 3069 || 20% / 60% || 8 || ADC2 || 9
|-
| 1A || B || OC1A || 3069 || 10% / 90% || 8 || ADC2 || 9
|-
| 1B || A || OC1B || 5115 || 25% / 75% || 1 || ADC4 || 8
|-
| 1B || B || OC1B || 5115 || 40% / 60% || 1 || ADC4 || 8
|-
| 2A || A || OC1A || 4092 || 25% / 50% || 8 || ADC1 || 7
|-
| 2A || B || OC1A || 4092 || 30% / 70% || 8 || ADC1 || 7
|-
| 2B || A || OC1B || 6138 || 25% / 50% || 1 || ADC3 || 6
|-
| 2B || B || OC1B || 6138 || 40% / 75% || 1 || ADC3 || 6
|}

=Travail à réaliser=
==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|5|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|1|vous pouvez brancher le moteur et valider le fonctionnement}}

==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 d'augmenter(diminuer) 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}}

==Mise en marche/arrêt==
{{Eval|2|Ajouter la gestion marche/arrêt avec un 1 bouton poussoir qui sera connecté sur la broche PD2 :}}

'''Vous devez utiliser une interruption pour réaliser cette fonction'''

*au 1er appui on met en route le moteur
*à l'appui suivant il s'arrête
*il n'y a pas besoin de maintenir le bouton pour que le moteur tourne
*on conserve le potentiomètre pour modifier la vitesse

<big>'''Attention'''</big>, le rapport cyclique n'est jamais nul, pour arrêter le moteur
*déconnecter la broche du timer ( bits COMxxx)
*mettre la sortie à 0

==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

Cours:TPS 2103 tp regulationVitesse

2026-03-12T09:21:20Z

Bjacquot : /* génération de MLI */

<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 || 3069 || 20% / 60% || 8 || ADC2 || 9
|-
| 1A || B || OC1A || 3069 || 10% / 90% || 8 || ADC2 || 9
|-
| 1B || A || OC1B || 5115 || 25% / 75% || 1 || ADC4 || 8
|-
| 1B || B || OC1B || 5115 || 40% / 60% || 1 || ADC4 || 8
|-
| 2A || A || OC1A || 4092 || 25% / 50% || 8 || ADC1 || 7
|-
| 2A || B || OC1A || 4092 || 30% / 70% || 8 || ADC1 || 7
|-
| 2B || A || OC1B || 6138 || 25% / 50% || 1 || ADC3 || 6
|-
| 2B || B || OC1B || 6138 || 40% / 75% || 1 || ADC3 || 6
|}

=Travail à réaliser=
==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|5|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|1|vous pouvez brancher le moteur et valider le fonctionnement}}

==Mise en marche/arrêt==
{{Eval|2|Ajouter la gestion marche/arrêt avec un 1 bouton poussoir qui sera connecté sur la broche PD2 :}}

'''Vous devez utiliser une interruption pour réaliser cette fonction'''

*au 1er appui on met en route le moteur
*à l'appui suivant il s'arrête
*il n'y a pas besoin de maintenir le bouton pour que le moteur tourne
*on conserve le potentiomètre pour modifier la vitesse

<big>'''Attention'''</big>, le rapport cyclique n'est jamais nul, pour arrêter le moteur
*déconnecter la broche du timer ( bits COMxxx)
*mettre la sortie à 0

==Asservissement de vitesse==
===Comptage par interruption===
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 d'augmenter(diminuer) 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}}

===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

Cours:TPS 2103 tp regulationVitesse

2026-03-12T09:13:54Z

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 || 3069 || 20% / 60% || 8 || ADC2 || 9
|-
| 1A || B || OC1A || 3069 || 10% / 90% || 8 || ADC2 || 9
|-
| 1B || A || OC1B || 5115 || 25% / 75% || 1 || ADC4 || 8
|-
| 1B || B || OC1B || 5115 || 40% / 60% || 1 || ADC4 || 8
|-
| 2A || A || OC1A || 4092 || 25% / 50% || 8 || ADC1 || 7
|-
| 2A || B || OC1A || 4092 || 30% / 70% || 8 || ADC1 || 7
|-
| 2B || A || OC1B || 6138 || 25% / 50% || 1 || ADC3 || 6
|-
| 2B || B || OC1B || 6138 || 40% / 75% || 1 || ADC3 || 6
|}

=Travail à réaliser=
==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)

Ecrire un programme qui :
*génère une mli
*dont on peut faire varier le rapport cylique avec le potentiomètre

#{{Eval|5|etape 1 :}}
#*pas de potentiomètre
#*générer la mli en respectant les contraintes
#*la visualiser à l'oscilloscope
#*vous vérifierez avec quelques valeurs différentes de rapport cyclique
#{{Eval|4|etape 2 :}}
#*ajouter le potentiomètre en respectant la broche indiquée dans les contraintes
#*faire varier le rapport cyclique linéairement en fonction du potentiomètre
#*le rapport cyclique devra varier de 0 à 100% suivant la position du potentiomètre
#{{Eval|1|etape 3 :}} vous pouvez brancher le moteur et valider le fonctionnement

==Mise en marche/arrêt==
{{Eval|2|Ajouter la gestion marche/arrêt avec un 1 bouton poussoir qui sera connecté sur la broche PD2 :}}

'''Vous devez utiliser une interruption pour réaliser cette fonction'''

*au 1er appui on met en route le moteur
*à l'appui suivant il s'arrête
*il n'y a pas besoin de maintenir le bouton pour que le moteur tourne
*on conserve le potentiomètre pour modifier la vitesse

<big>'''Attention'''</big>, le rapport cyclique n'est jamais nul, pour arrêter le moteur
*déconnecter la broche du timer ( bits COMxxx)
*mettre la sortie à 0

==Asservissement de vitesse==
===Comptage par interruption===
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 d'augmenter(diminuer) 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}}

===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

Cours:TPS 2103 tp regulationVitesse

2026-03-12T09:13:35Z

Bjacquot : /* génération de MLI */

<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 !! prédiviseur !! valeurs de rapport cyclique !! entrée potar !! nombre d'incréments / 10ms
|-
| 1A || A || OC1A || 3069 || 20% / 60% || 8 || ADC2 || 9
|-
| 1A || B || OC1A || 3069 || 10% / 90% || 8 || ADC2 || 9
|-
| 1B || A || OC1B || 5115 || 25% / 75% || 1 || ADC4 || 8
|-
| 1B || B || OC1B || 5115 || 40% / 60% || 1 || ADC4 || 8
|-
| 2A || A || OC1A || 4092 || 25% / 50% || 8 || ADC1 || 7
|-
| 2A || B || OC1A || 4092 || 30% / 70% || 8 || ADC1 || 7
|-
| 2B || A || OC1B || 6138 || 25% / 50% || 1 || ADC3 || 6
|-
| 2B || B || OC1B || 6138 || 40% / 75% || 1 || ADC3 || 6
|}

=Travail à réaliser=
==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)

Ecrire un programme qui :
*génère une mli
*dont on peut faire varier le rapport cylique avec le potentiomètre

#{{Eval|5|etape 1 :}}
#*pas de potentiomètre
#*générer la mli en respectant les contraintes
#*la visualiser à l'oscilloscope
#*vous vérifierez avec quelques valeurs différentes de rapport cyclique
#{{Eval|4|etape 2 :}}
#*ajouter le potentiomètre en respectant la broche indiquée dans les contraintes
#*faire varier le rapport cyclique linéairement en fonction du potentiomètre
#*le rapport cyclique devra varier de 0 à 100% suivant la position du potentiomètre
#{{Eval|1|etape 3 :}} vous pouvez brancher le moteur et valider le fonctionnement

==Mise en marche/arrêt==
{{Eval|2|Ajouter la gestion marche/arrêt avec un 1 bouton poussoir qui sera connecté sur la broche PD2 :}}

'''Vous devez utiliser une interruption pour réaliser cette fonction'''

*au 1er appui on met en route le moteur
*à l'appui suivant il s'arrête
*il n'y a pas besoin de maintenir le bouton pour que le moteur tourne
*on conserve le potentiomètre pour modifier la vitesse

<big>'''Attention'''</big>, le rapport cyclique n'est jamais nul, pour arrêter le moteur
*déconnecter la broche du timer ( bits COMxxx)
*mettre la sortie à 0

==Asservissement de vitesse==
===Comptage par interruption===
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 d'augmenter(diminuer) 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}}

===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

Cours:TPS 2103 tp regulationVitesse

2026-03-12T09:09:04Z

Bjacquot : /* Validation de la MLI */

<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 !! prédiviseur !! valeurs de rapport cyclique !! entrée potar !! nombre d'incréments / 10ms
|-
| 1A || A || OC1A || 3069 || 20% / 60% || 8 || ADC2 || 9
|-
| 1A || B || OC1A || 3069 || 10% / 90% || 8 || ADC2 || 9
|-
| 1B || A || OC1B || 5115 || 25% / 75% || 1 || ADC4 || 8
|-
| 1B || B || OC1B || 5115 || 40% / 60% || 1 || ADC4 || 8
|-
| 2A || A || OC1A || 4092 || 25% / 50% || 8 || ADC1 || 7
|-
| 2A || B || OC1A || 4092 || 30% / 70% || 8 || ADC1 || 7
|-
| 2B || A || OC1B || 6138 || 25% / 50% || 1 || ADC3 || 6
|-
| 2B || B || OC1B || 6138 || 40% / 75% || 1 || ADC3 || 6
|}

=Travail à réaliser=
==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

Ecrire un programme qui :
*génère une mli
*dont on peut faire varier le rapport cylique avec le potentiomètre

#{{Eval|5|etape 1 :}}
#*pas de potentiomètre
#*générer la mli en respectant les contraintes
#*la visualiser à l'oscilloscope
#*vous vérifierez avec quelques valeurs différentes de rapport cyclique
#{{Eval|4|etape 2 :}}
#*ajouter le potentiomètre en respectant la broche indiquée dans les contraintes
#*faire varier le rapport cyclique linéairement en fonction du potentiomètre
#*le rapport cyclique devra varier de 0 à 100% suivant la position du potentiomètre
#{{Eval|1|etape 3 :}} vous pouvez brancher le moteur et valider le fonctionnement

==Mise en marche/arrêt==
{{Eval|2|Ajouter la gestion marche/arrêt avec un 1 bouton poussoir qui sera connecté sur la broche PD2 :}}

'''Vous devez utiliser une interruption pour réaliser cette fonction'''

*au 1er appui on met en route le moteur
*à l'appui suivant il s'arrête
*il n'y a pas besoin de maintenir le bouton pour que le moteur tourne
*on conserve le potentiomètre pour modifier la vitesse

<big>'''Attention'''</big>, le rapport cyclique n'est jamais nul, pour arrêter le moteur
*déconnecter la broche du timer ( bits COMxxx)
*mettre la sortie à 0

==Asservissement de vitesse==
===Comptage par interruption===
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 d'augmenter(diminuer) 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}}

===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

Cours:TPS 2103 tp regulationVitesse

2026-03-12T08:39:45Z

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 !! prédiviseur !! valeurs de rapport cyclique !! entrée potar !! nombre d'incréments / 10ms
|-
| 1A || A || OC1A || 3069 || 20% / 60% || 8 || ADC2 || 9
|-
| 1A || B || OC1A || 3069 || 10% / 90% || 8 || ADC2 || 9
|-
| 1B || A || OC1B || 5115 || 25% / 75% || 1 || ADC4 || 8
|-
| 1B || B || OC1B || 5115 || 40% / 60% || 1 || ADC4 || 8
|-
| 2A || A || OC1A || 4092 || 25% / 50% || 8 || ADC1 || 7
|-
| 2A || B || OC1A || 4092 || 30% / 70% || 8 || ADC1 || 7
|-
| 2B || A || OC1B || 6138 || 25% / 50% || 1 || ADC3 || 6
|-
| 2B || B || OC1B || 6138 || 40% / 75% || 1 || ADC3 || 6
|}

=Travail à réaliser=
==Validation de la MLI==
Ecrire un programme qui :
*génère une mli
*dont on peut faire varier le rapport cylique avec le potentiomètre

#{{Eval|5|etape 1 :}}
#*pas de potentiomètre
#*générer la mli en respectant les contraintes
#*la visualiser à l'oscilloscope
#*vous vérifierez avec quelques valeurs différentes de rapport cyclique
#{{Eval|4|etape 2 :}}
#*ajouter le potentiomètre en respectant la broche indiquée dans les contraintes
#*faire varier le rapport cyclique linéairement en fonction du potentiomètre
#*le rapport cyclique devra varier de 0 à 100% suivant la position du potentiomètre
#{{Eval|1|etape 3 :}} vous pouvez brancher le moteur et valider le fonctionnement

==Mise en marche/arrêt==
{{Eval|2|Ajouter la gestion marche/arrêt avec un 1 bouton poussoir qui sera connecté sur la broche PD2 :}}

'''Vous devez utiliser une interruption pour réaliser cette fonction'''

*au 1er appui on met en route le moteur
*à l'appui suivant il s'arrête
*il n'y a pas besoin de maintenir le bouton pour que le moteur tourne
*on conserve le potentiomètre pour modifier la vitesse

<big>'''Attention'''</big>, le rapport cyclique n'est jamais nul, pour arrêter le moteur
*déconnecter la broche du timer ( bits COMxxx)
*mettre la sortie à 0

==Asservissement de vitesse==
===Comptage par interruption===
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 d'augmenter(diminuer) 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}}

===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

Cours:InfoS2 tdI2c

2026-03-11T08:34:52Z

Bjacquot : /* Ecrire sur le slave : Envoyer des données du controller à la target i2c */

{{EnTeteTdInfoS2|InfoS2 tdI2c prof}}

Fichiers pour simulide : [[Media:infoI2cTd1.zip|I2cTd1.zip]]

{{Rouge|**************************************************}}
{{Rouge|*** Attention, programme dans un fichier .ino ***}}
{{Rouge|**************************************************}}

=Framework Arduino=

Lors des tds précédents, nous avons utilisé uniquement les fonctions de la {{Rouge|bibliothèque standard libc}} pour avr.

{{Rouge|L'inconvénient}} principal réside dans la nécessité de devoir {{Rouge|écrire/adapter un programme}} pour chaque µcontroleur (aussi nommé {{Rouge|cible}}). {{Rouge|L'avantage}} principal est d'avoir un programme très {{Rouge|efficient}} en terme de taille d'exécutable et de rapidité d'exécution, et également beaucoup {{Rouge|plus simple à écrire}}.

Afin de simplifier le changement de cible, on utilise le concept de {{Rouge|couches d'abstractions}}.

[[Image:CoucheAbstraction.png|400px]]

L'idée sous-jacente est de ne pas faire un programme qui s'occupe de gérer directement les périphériques, mais utilise des fonctions qui s'occupent de faire le lien, un exemple sera plus parlant !

<source lang=cpp>
PORTB|=(1<<PB0);
digialWrite(8,1);
</source>
Ces 2 instructions sont équivalentes pour une carte arduino UNO, elles mettent toutes les 2 à 1 la broche étiquetée 8 sur cette carte.

Si nous changeons de carte (arduino Mega par ex), la broche utilisée sur le µcontroleur n'est pas la même et il faut alors remplacer :
<source lang=cpp>
PORTH|=(1<<PH5);
digialWrite(8,1);
</source>

L'intérêt est ici évident de l'utilisation du {{Rouge|framework}} (ensemble de fonctions) arduino qui permet d'écrire un {{Rouge|programme quasiment indépendant de la carte (cible) utilisée}}.

Si nous parlons {{Rouge|d'efficacité}} par contre, la fonction {{Rouge|digialWrite}} est environ {{Rouge|20 fois moins rapide}} !

Il existe quelques framework pour les cibles {{Rouge|avr}} (famille des µcontroleurs aTmega ATtiny), nous utiliserons le {{Rouge|framework arduino}} pour utiliser la {{Rouge|liaison i2c}}, l'utilisation du périphérique du µcontroleur étant assez fastidieux à configurer.

== En pratique sur Simulide ==

* Télécharger l'archive <code>I2cTd1.zip</code> (en haut de ce document)
* Dans Simulide : ouvrir le fichier <code>schemaI2cTd1.sim</code>
* Le programme doit être écrit dans un fichier d'extension <code>.ino</code> et enregistré dans le dossier décompressé (qui ne doit pas contenir d'autres fichier .c ou .cpp)
* La ligne habituelle <code>// Compiler: Avrgcc device: nomDuMicrocontroleur</code> est ici inutile
* Dans <code>compiler/settings</code>, vous devez indiquer le chemin du ''tool path'' Arduino : <code>/opt/arduino-1.8.19/</code> (avec les <code>/</code>). Contrôler que la carte est bien une 'Uno'.
* Pour ouvrir un moniteur série : clic droit sur le composant et sélectionner ''ouvrir le moniteur série'', puis ''USart1''

=Trouver les adresses des "targets" (esclave i2c)=

On programmera pour le moment uniquement la carte "controller" (identifiée carte n°2 sur tinkercad).

{{Question|L'adresse d'un composant i2c étant codée sur 7 bits, quel est le nombre d'@ au total}}

'''Rque''' : certaines adresses sont réservées et non utilisables pour les périphériques.

{{Question|Trouvez les adresses des targets en utilisant le programme suivant :}}

'''Rque''' :
*les valeurs s'affichent dans le moniteur série
*il n'est pas nécessaire de comprendre le programme, ça viendra plus tard.

<source lang=cpp>
#include <Wire.h>
int main()
{
Serial.begin(115200);
Serial.println("I2C Scanner\n");
Wire.begin();
sei();
while(1)
{
byte error, address;
int nDevices;
Serial.println("Scanning...");
nDevices = 0;
for(address = 1; address < 127; address++ )
{
// The i2c_scanner uses the return value of
// the Write.endTransmisstion to see if
// a device did acknowledge to the address.
Wire.beginTransmission(address);
error = Wire.endTransmission();
if (error == 0)
{
Serial.print("I2C device found at address 0x");
if (address<16) Serial.print("0");
Serial.print(address,HEX);
Serial.println(" !");
nDevices++;
}
else if (error==4)
{
Serial.print("Unknown error at address 0x");
if (address<16) Serial.print("0");
Serial.println(address,HEX);
}
}
if (nDevices == 0) Serial.println("No I2C devices found\n");
else Serial.println("done\n");
_delay_ms(100); // wait 5 seconds for next scan
}
}
</source>

=Ecrire sur le slave : Envoyer des données du controller à la target i2c=

Nous utilisons la librairie [https://www.arduino.cc/en/Reference/Wire Wire] du framework arduino.

Pour envoyer des données vers la target i2c, il convient de :
*indiquer l'@ de la target
*envoyer la (ou les) donnée(s)
*fermer la connection

Ce qui donne :
<source lang=cpp>
#include <Wire.h>
const uint8_t slaveAdress=0x04; // ou 4 ou 0b100 !
uint8_t value = 0b10101010;

int main()
{
Wire.begin(); // join i2c bus (address optional for master)
sei(); // la librairie Wire utilise des interruptions
while(1)
{
Wire.beginTransmission(slaveAdress); // transmit to device #4
Wire.write(value); // sends one byte
Wire.endTransmission(); // stop transmitting

_delay_ms(100);
}
}
</source>

{{Question|Modifier le programme pour envoyer la donnée à la carte arduino sur laquelle sont branchées les leds, et faire en sorte que les leds allumées changent toutes les 200ms par ex}}

{{Question|Faire une fonction pour écrire une valeur en i2c}}

=Lire sur le slave : la target envoie des données au controller=

Le transfert de données de la target vers le controller se passe de façon un peu différente. On programme le controller de la façon suivante :
*demander à un périphérique i2c d'envoyer un certain nombre de données (octets, 8 bits donc)
*tant qu'il y a des données i2c à lire :
**lire la donnée

ce qui donne :
<source lang=cpp>
#include <Wire.h>
const uint8_t slaveAdress=0x04; // ou 4 ou 0b100 !
uint8_t value;

int main()
{
Wire.begin(); // join i2c bus (address optional for master)
Serial.begin(9600); // start serial for output
sei(); // pour la librairie Wire
while(1)
{
Wire.requestFrom(slaveAdress, 1); // request 1 bytes(octet) from peripheral device @4
value = Wire.read(); // receive a byte as character

Serial.println(value); // print the character
_delay_ms(500);
}
}
</source>

{{Question|Modifier le programme pour obtenir de la carte arduino sur laquelle est branchée le potentiomètre la "valeur" de celui-ci toutes les 200ms.}}

{{Question|Faire une fonction pour lire une valeur en i2c}}

=Utilisation des 2 targets=

{{Question|Réunissez vos 2 programmes pour faire en sorte que le potentiomètre serve à modifier l'état des leds, par ex :}}
*afficher la valeur du potar sur les leds
*faire un chenillard piloté par le potentiomètre

'''Rque''' : on ne changera pas le programme des targets.

=Ajout d'une autre target=

{{Todo|Dupliquer les cartes arduino avec les leds et le potetiomètre}}
*Il y aura donc
**2 cartes avec des leds
**2 cartes avec un potentiomètre
*pour modifier l'@ des cibles i2c, modifier le niveau logique sur les broches PB0 et PB1

{{Question|Modifier votre programme pour que chaque potentiomètre pilote une série de leds différentes.}}