troyesGEII - Contributions de l’utilisateur [fr]

Cours:TPS 2103 tp evitementObstacles

2019-06-11T07:31:00Z

Ech-01 : Annulation des modifications 11560 de Ech-01 (discussion)

<accesscontrol>Acces:Prof</accesscontrol>
[[Cours:TPs_2103|{{Rouge|<big>'''Retour à la liste des Tps'''</big>}}]]

[[Cours:TPS_2103_tp_evitementObstacles_corr|{{Vert|<big>'''Correction avec accès restreint'''</big>}}]]

={{Rouge|Gestion des moteurs}}=
Dans un précédent TP, vous avez travaillé avec des [[Cours:TPS_2103_tp_miniqv2#moteur_.21|Utilitaires de gestion des moteurs]].

'''Pour information''' :
* la marche avant du moteur gauche se fait en mettant à 0 '''PD6''' tandis que la marche arrière consiste à mettre '''PD6''' à 1
* la marche avant du moteur droit se fait en mettant à 0 '''PE6''' tandis que la marche arrière consiste à mettre '''PE6''' à 1
* les deux bits ci-dessus sont déjà configurés en sortie dans "void initMoteur()"

{{Question|Montrer que vous êtes capable de faire une marche avant, de tourner sur place d'environ 90° et de partir en marche arrière.}}

={{Rouge|Gestion de l'infrarouge frontale}}=

=={{Bleu|Principe}}==

Sont présents sur le robot, un détecteur infrarouge et deux émetteurs dirigés respectivement vers la droite et vers la gauche. Ils permettent de savoir si le nombre d'impulsions reçu (par écho) peut laisser penser à la présence d'un obstacle. Le détecteur est relié à INT0/PB0 et peut donc être géré par une interruption qui ne fera que compter le nombre d'impulsions reçu. A noter que cette interruption est incapable, par elle-même de savoir qui a émis, la droite ou la gauche.

L'idée générale est donc d'envoyer un train d'impulsions en émission et de compter ce que l'on reçoit.

=={{Bleu|Récepteur}}==

Il convient de configurer l'interruption de changement d'état associé à la broche '''PB0/PCINT0'''.

Afin de faciliter la recherche de documentation, cette broche est associée à l'interruption PCI0 et ne nom de l'interruption est {{Rouge|PCINT0_vect}}.

On utilisera la led pour tester la bonne configuration de l'interruption ([[Cours:TPS_2103_tp_miniqv2#D.C3.A9bogage|cf tp précédent]]).

{{Question|A l'aide [[media:atmega32u4.pdf|de la documentation atmel, pages 91]], faire en sorte que la led s'allume à chaque réception}}
*on utilisera la télécommande pour émettre un signal
*on peut allumer la led dans l'interruption
*l'éteindre au bout d'un certain temps dans la boucle principale

<source lang=c>
#include ....
volatile uint8_t flag=0;

ISR(PCINT0_vect)
{

}

void main()
{
// configuration de l'interruption

while(1)
{
}
}
</source>

Ça marche .... on souhaite maintenant qu'un compteur s'incrémente à chaque interruption.

{{Question|Apporter les modifications nécessaires}}

=={{Bleu|Émetteur}}==

Le robot dispose de 2 émetteurs infrarouges dont le tableau suivant donne les informations importantes :

{| class="wikitable"
|-
! Position !! Patte !! Timer
|-
| Droite || PB4 || ----
|-
| Gauche || PC7 || OC4A
|}

Les deux émetteurs sont pilotés à 38 kHz. Si vous suivez, il va falloir de nouveau configurer un timer pour cela ! Le tableau ci-dessus pourrait laisser penser qu'il faut prendre le timer 4, mais on rappelle que l'on utilise déjà ce timer pour la MLI des moteurs. On décide de prendre le TIMER0.

On rappelle que l'on aura besoin de code à travers une interruption pour basculer '''PB4''' et '''PC7''' puisqu'ils ne sont reliés à aucun '''OC0X'''.

==={{Vert|émetteurs et Timer0}}===

[[File:AVR_Timer0_comp.png|thumb|250px|La comparaison avec le timer 0]]

Nous allons utiliser le mode comparaison du timer0 afin d'obtenir une fréquence très précise d'émission de 38kHz.

{{Question|Choisir des valeurs de prédiviseur et de comparaison permettant d'obtenir une fréquence de comparaison de 76kHz}}

{{Question|Ajouter la configuration du timer a votre programme avec un sous-programme :}}

<source lang=c>
void setTIMER0_interrupt_ctc()
{
// set PB4 and PC7 as output

// choix du prédiviseur

// mode remise à zéro sur comparaison (mode CTC = (010) contrairement à la figure !!!

// valeur de OCR0A

// autorisation de l'interruption de comparaison (bit OCIE0A du registre TIMSK0)

}
</source>

{{Question|Ajouter l'interruption de comparaison associée a votre programme. N'oubliez pas que cette interruption doit émettre soit du côté droit soit du côté gauche. Il faudra donc lui associer une variable globale "volatile uint8_t left;" qui conditionnera si l'émission se fait à droite ou à gauche. Par exemple :}}
<source lang=c>
volatile uint8_t left=0;
ISR(TIMER0_COMPA_vect)
{
if (left)
// émettre à gauche
else
//.....?????

}
</source>
A ce point, il faut bien comprendre ce que l'on est capable de faire :
* un sei() dans le programme principal déclenchera automatiquement une émission à droite ou à gauche (suivant la valeur de la variable "left").
* par conséquent l'interruption "ISR(PCINT0_vect)" comptera toujours les éventuels échos.
* si vous voulez arrêter d'émettre il vous faudra soit réaliser un cli() (déconseillé) soit désactiver l'interruption ISR(TIMER0_COMPA_vect) avec le bit '''OCIE0A''' du registre '''TIMSK0'''.

==={{Vert|Émission droite/gauche}}===

Pour commencer on utilisera les primitives "_delay_us()" pour attendre quelques microsecondes.

* left <- 0
* count <- 0
*Répéter 20 fois :
**Émettre pendant 300us sur l'émetteur droit en autorisant l'interruption de comparaison
**Arrêter d'émettre : on coupe l'émission pendant 600 us
*Lire valeur du compteur de réception.

On doit faire la même chose avec l'émission à gauche.

* left <- 1
* count <- 0
*Répéter 20 fois :
**Émettre pendant 300us sur l'émetteur gauche en autorisant l'interruption de comparaison
**Arrêter d'émettre : on coupe l'émission pendant 600 us
*Lire valeur du compteur de réception.

{{Question|Écrire un programme qui : }}
*éteint la led lorsqu'il n'y a pas d'obstacles
*allume en vert si obstacle à droite
*allume en bleu si obstacle à gauche
*allume en rouge si obstacle à droite et à gauche

'''Remarque''' :
*Vous pouvez/devez utiliser [[Cours:TPS_2103_tp_miniqv2#D.C3.A9bogage|les fonctions disponibles pour la LED RGB]]
*Un seuil de 20 est satisfaisant pour la valeur de comptage lors de la présence d'un obstacle

={{Rouge|Évitement d'obstacles}}=

Vous allez maintenant faire fonctionner en même temps le calcul des échos de la deuxième section avec la gestion des moteurs de la première section.

{{Question|Écrire un programme qui répond au cahier des charges suivant :}}

*Boucler
**le robot avance en ligne droite
**s'il y a un obstacle à droite (count >20 par ex) alors
***reculer
***tourner sur place vers la gauche
***reprendre la ligne droite en marche avant
**s'il y a un obstacle à gauche (count >20 par ex) alors
***reculer
***tourner sur place vers la droite
***reprendre la ligne droite en marche avant

Cours:TPS 2103 tp evitementObstacles

2019-06-11T07:30:46Z

Ech-01 :

[[Cours:TPs_2103|{{Rouge|<big>'''Retour à la liste des Tps'''</big>}}]]

[[Cours:TPS_2103_tp_evitementObstacles_corr|{{Vert|<big>'''Correction avec accès restreint'''</big>}}]]

={{Rouge|Gestion des moteurs}}=
Dans un précédent TP, vous avez travaillé avec des [[Cours:TPS_2103_tp_miniqv2#moteur_.21|Utilitaires de gestion des moteurs]].

'''Pour information''' :
* la marche avant du moteur gauche se fait en mettant à 0 '''PD6''' tandis que la marche arrière consiste à mettre '''PD6''' à 1
* la marche avant du moteur droit se fait en mettant à 0 '''PE6''' tandis que la marche arrière consiste à mettre '''PE6''' à 1
* les deux bits ci-dessus sont déjà configurés en sortie dans "void initMoteur()"

{{Question|Montrer que vous êtes capable de faire une marche avant, de tourner sur place d'environ 90° et de partir en marche arrière.}}

={{Rouge|Gestion de l'infrarouge frontale}}=

=={{Bleu|Principe}}==

Sont présents sur le robot, un détecteur infrarouge et deux émetteurs dirigés respectivement vers la droite et vers la gauche. Ils permettent de savoir si le nombre d'impulsions reçu (par écho) peut laisser penser à la présence d'un obstacle. Le détecteur est relié à INT0/PB0 et peut donc être géré par une interruption qui ne fera que compter le nombre d'impulsions reçu. A noter que cette interruption est incapable, par elle-même de savoir qui a émis, la droite ou la gauche.

L'idée générale est donc d'envoyer un train d'impulsions en émission et de compter ce que l'on reçoit.

=={{Bleu|Récepteur}}==

Il convient de configurer l'interruption de changement d'état associé à la broche '''PB0/PCINT0'''.

Afin de faciliter la recherche de documentation, cette broche est associée à l'interruption PCI0 et ne nom de l'interruption est {{Rouge|PCINT0_vect}}.

On utilisera la led pour tester la bonne configuration de l'interruption ([[Cours:TPS_2103_tp_miniqv2#D.C3.A9bogage|cf tp précédent]]).

{{Question|A l'aide [[media:atmega32u4.pdf|de la documentation atmel, pages 91]], faire en sorte que la led s'allume à chaque réception}}
*on utilisera la télécommande pour émettre un signal
*on peut allumer la led dans l'interruption
*l'éteindre au bout d'un certain temps dans la boucle principale

<source lang=c>
#include ....
volatile uint8_t flag=0;

ISR(PCINT0_vect)
{

}

void main()
{
// configuration de l'interruption

while(1)
{
}
}
</source>

Ça marche .... on souhaite maintenant qu'un compteur s'incrémente à chaque interruption.

{{Question|Apporter les modifications nécessaires}}

=={{Bleu|Émetteur}}==

Le robot dispose de 2 émetteurs infrarouges dont le tableau suivant donne les informations importantes :

{| class="wikitable"
|-
! Position !! Patte !! Timer
|-
| Droite || PB4 || ----
|-
| Gauche || PC7 || OC4A
|}

Les deux émetteurs sont pilotés à 38 kHz. Si vous suivez, il va falloir de nouveau configurer un timer pour cela ! Le tableau ci-dessus pourrait laisser penser qu'il faut prendre le timer 4, mais on rappelle que l'on utilise déjà ce timer pour la MLI des moteurs. On décide de prendre le TIMER0.

On rappelle que l'on aura besoin de code à travers une interruption pour basculer '''PB4''' et '''PC7''' puisqu'ils ne sont reliés à aucun '''OC0X'''.

==={{Vert|émetteurs et Timer0}}===

[[File:AVR_Timer0_comp.png|thumb|250px|La comparaison avec le timer 0]]

Nous allons utiliser le mode comparaison du timer0 afin d'obtenir une fréquence très précise d'émission de 38kHz.

{{Question|Choisir des valeurs de prédiviseur et de comparaison permettant d'obtenir une fréquence de comparaison de 76kHz}}

{{Question|Ajouter la configuration du timer a votre programme avec un sous-programme :}}

<source lang=c>
void setTIMER0_interrupt_ctc()
{
// set PB4 and PC7 as output

// choix du prédiviseur

// mode remise à zéro sur comparaison (mode CTC = (010) contrairement à la figure !!!

// valeur de OCR0A

// autorisation de l'interruption de comparaison (bit OCIE0A du registre TIMSK0)

}
</source>

{{Question|Ajouter l'interruption de comparaison associée a votre programme. N'oubliez pas que cette interruption doit émettre soit du côté droit soit du côté gauche. Il faudra donc lui associer une variable globale "volatile uint8_t left;" qui conditionnera si l'émission se fait à droite ou à gauche. Par exemple :}}
<source lang=c>
volatile uint8_t left=0;
ISR(TIMER0_COMPA_vect)
{
if (left)
// émettre à gauche
else
//.....?????

}
</source>
A ce point, il faut bien comprendre ce que l'on est capable de faire :
* un sei() dans le programme principal déclenchera automatiquement une émission à droite ou à gauche (suivant la valeur de la variable "left").
* par conséquent l'interruption "ISR(PCINT0_vect)" comptera toujours les éventuels échos.
* si vous voulez arrêter d'émettre il vous faudra soit réaliser un cli() (déconseillé) soit désactiver l'interruption ISR(TIMER0_COMPA_vect) avec le bit '''OCIE0A''' du registre '''TIMSK0'''.

==={{Vert|Émission droite/gauche}}===

Pour commencer on utilisera les primitives "_delay_us()" pour attendre quelques microsecondes.

* left <- 0
* count <- 0
*Répéter 20 fois :
**Émettre pendant 300us sur l'émetteur droit en autorisant l'interruption de comparaison
**Arrêter d'émettre : on coupe l'émission pendant 600 us
*Lire valeur du compteur de réception.

On doit faire la même chose avec l'émission à gauche.

* left <- 1
* count <- 0
*Répéter 20 fois :
**Émettre pendant 300us sur l'émetteur gauche en autorisant l'interruption de comparaison
**Arrêter d'émettre : on coupe l'émission pendant 600 us
*Lire valeur du compteur de réception.

{{Question|Écrire un programme qui : }}
*éteint la led lorsqu'il n'y a pas d'obstacles
*allume en vert si obstacle à droite
*allume en bleu si obstacle à gauche
*allume en rouge si obstacle à droite et à gauche

'''Remarque''' :
*Vous pouvez/devez utiliser [[Cours:TPS_2103_tp_miniqv2#D.C3.A9bogage|les fonctions disponibles pour la LED RGB]]
*Un seuil de 20 est satisfaisant pour la valeur de comptage lors de la présence d'un obstacle

={{Rouge|Évitement d'obstacles}}=

Vous allez maintenant faire fonctionner en même temps le calcul des échos de la deuxième section avec la gestion des moteurs de la première section.

{{Question|Écrire un programme qui répond au cahier des charges suivant :}}

*Boucler
**le robot avance en ligne droite
**s'il y a un obstacle à droite (count >20 par ex) alors
***reculer
***tourner sur place vers la gauche
***reprendre la ligne droite en marche avant
**s'il y a un obstacle à gauche (count >20 par ex) alors
***reculer
***tourner sur place vers la droite
***reprendre la ligne droite en marche avant

Cours:TPS 2103 tp mesureDeDistance

2019-06-11T07:29:42Z

Ech-01 : Annulation des modifications 11558 de Ech-01 (discussion)

<accesscontrol>Acces:Prof</accesscontrol>
[[Cours:TPs_2103|{{Rouge|<big>'''Retour à la liste des Tps'''</big>}}]]

[[Cours:TPS_2103_tp_mesureDeDistance_corr|{{Vert|<big>Les corrections sont en accès restreint</big>}}]]

[[Fichier:ArduinoPinout.png|vignette]]

{{Vert|<big>'''UNO sans arduino'''</big> : par commodité, nous utiliserons une carte arduino UNO pour programmer un ATMEGA328p.}}

{{Vert|Cependant, nous n'utiliserons ni la librairie arduino, ni le logiciel dédié.}}

La programmation de la carte sera réalisée sur l'IDE {{Rouge|ECLIPSE}} et nous utiliserons la librairie avr-libc (avr/io.h, util/delay.h ...).

L'objectif est ici de faire une mesure de distance et d'afficher cette mesure à l'aide d'un curseur qui sera positionné sur un servomoteur.

={{Rouge|C'est parti !}}=

[[Fichier:Usart atmega328.png|vignette]]

Pour simplifier débogage et mise au point, vous allez configurer la liaison série avec les caractéristiques suivantes :
*8 bits de données
*pas de parité
*1 bit de stop
*9600 bauds

Vous vous servirez :
*de la figure ci-contre
*[[media:atmega328p.pdf|de la documentation atmel, pages 190 et suivantes]]

{{Question|En utilisant les fonctions uart_putchar et uart_init, écrire un programme qui envoie en boucle "alive"}}

<source lang=c>
void uart_putchar(char c)
{
loop_until_bit_is_set(UCSR0A, UDRE0); /* Wait until data register empty. */
UDR0 = c;
}

void uart_init()
{
// a completer
}

int main()
{
....
while(1)
{
....
}
}
</source>

={{Rouge|HC-SR04}}=

Vous pouvez commencer par lire [[media:HCSR04.pdf|la documentation du module]].

=={{Bleu|Trigger}}==
On souhaite faire une nouvelle mesure toutes les 100ms.

Pour effectuer cette action répétitive, il convient d'utiliser un timer. Ce sera le timer1.
{|
|-
| [[Fichier:AVRMega328 Timer1.png|thumb|500px|Documentation simple du Timer 1 (16 bits)]] || [[File:AVRMega328_Timer1_Comparaison.png|thumb|500px|center|La comparaison avec le Timer 1 (16 bits)]]
|}

{{Question|Configurez ce timer en mode CTC pour générer une interruption de comparaison toutes les 100ms}}
*Attention à bien
**autoriser l'interruption de comparaison : TIMSK1|=1<<OCIE1A
**autoriser globalement les interruptions : sei()
**la fonction d'interruption sera définie par : ISR(TIMER1_COMPA_vect)
*Utiliser la led de la carte arduino (PB5) pour vérifier le bon fonctionnement

{{Question|Modifier votre interruption pour générer le signal Trigger en respectant la durée indiquée dans la datasheet}}

'''Remarque''' : Un oscilloscope sera nécessaire pour vérifier la forme du signal

=={{Bleu|Echo}}==

Bien, nous pouvons maintenant nous intéresser au signal echo, dont il vous faudra mesurer la durée.

Donc .... un autre timer ! Ce sera le timer2.

On souhaite avoir une précision au cm près :

sachant que t(uS)/58 = d(cm), chaque 58µs correspond donc à 1cm.

{{Question|Configurer ce timer pour qu'il déborde toutes les 58µs, et incrémente une variable distance à chaque interruption de débordement}}

On utilisera la broche INT0 pour le signal echo.

{{Question|Écrire un programme qui :}}
*lance le timer1
*répète
**attendre que echo=1
**lancer timer2
**attendre que echo=0
**arrêter timer2
**envoie la distance sur la liaison série
**remettre la distance à 0
**remettre le timer à 0

={{Rouge|Visualisation de la distance}}=

Entre en jeu le servomoteur et sa mli .... et donc le dernier timer disponible : timer0 !
[[File:TiemposServo.svg|TiemposServo]]

=={{Bleu|Test du servo}}==

{{Question|Configurez le timer0 pour générer une MLI sur OCR0A ou OCR0B au choix}}
*la fréquence de MLI a assez peu d'importance
*on souhaite juste un déplacement du servomoteur entre 2 positions

=={{Bleu|Couplage avec mesure de distance}}==

{{Question|Faire en sorte que la position du servomoteur indique la distance mesurée par le capteur ultrason}}

* [https://www.youtube.com/watch?v=rTM5gZxBPmY Vidéo Youtube expliquant ce que l'on cherche à faire]

Cours:TPS 2103 tp mesureDeDistance

2019-06-11T07:29:29Z

Ech-01 :

[[Cours:TPs_2103|{{Rouge|<big>'''Retour à la liste des Tps'''</big>}}]]

[[Cours:TPS_2103_tp_mesureDeDistance_corr|{{Vert|<big>Les corrections sont en accès restreint</big>}}]]

[[Fichier:ArduinoPinout.png|vignette]]

{{Vert|<big>'''UNO sans arduino'''</big> : par commodité, nous utiliserons une carte arduino UNO pour programmer un ATMEGA328p.}}

{{Vert|Cependant, nous n'utiliserons ni la librairie arduino, ni le logiciel dédié.}}

La programmation de la carte sera réalisée sur l'IDE {{Rouge|ECLIPSE}} et nous utiliserons la librairie avr-libc (avr/io.h, util/delay.h ...).

L'objectif est ici de faire une mesure de distance et d'afficher cette mesure à l'aide d'un curseur qui sera positionné sur un servomoteur.

={{Rouge|C'est parti !}}=

[[Fichier:Usart atmega328.png|vignette]]

Pour simplifier débogage et mise au point, vous allez configurer la liaison série avec les caractéristiques suivantes :
*8 bits de données
*pas de parité
*1 bit de stop
*9600 bauds

Vous vous servirez :
*de la figure ci-contre
*[[media:atmega328p.pdf|de la documentation atmel, pages 190 et suivantes]]

{{Question|En utilisant les fonctions uart_putchar et uart_init, écrire un programme qui envoie en boucle "alive"}}

<source lang=c>
void uart_putchar(char c)
{
loop_until_bit_is_set(UCSR0A, UDRE0); /* Wait until data register empty. */
UDR0 = c;
}

void uart_init()
{
// a completer
}

int main()
{
....
while(1)
{
....
}
}
</source>

={{Rouge|HC-SR04}}=

Vous pouvez commencer par lire [[media:HCSR04.pdf|la documentation du module]].

=={{Bleu|Trigger}}==
On souhaite faire une nouvelle mesure toutes les 100ms.

Pour effectuer cette action répétitive, il convient d'utiliser un timer. Ce sera le timer1.
{|
|-
| [[Fichier:AVRMega328 Timer1.png|thumb|500px|Documentation simple du Timer 1 (16 bits)]] || [[File:AVRMega328_Timer1_Comparaison.png|thumb|500px|center|La comparaison avec le Timer 1 (16 bits)]]
|}

{{Question|Configurez ce timer en mode CTC pour générer une interruption de comparaison toutes les 100ms}}
*Attention à bien
**autoriser l'interruption de comparaison : TIMSK1|=1<<OCIE1A
**autoriser globalement les interruptions : sei()
**la fonction d'interruption sera définie par : ISR(TIMER1_COMPA_vect)
*Utiliser la led de la carte arduino (PB5) pour vérifier le bon fonctionnement

{{Question|Modifier votre interruption pour générer le signal Trigger en respectant la durée indiquée dans la datasheet}}

'''Remarque''' : Un oscilloscope sera nécessaire pour vérifier la forme du signal

=={{Bleu|Echo}}==

Bien, nous pouvons maintenant nous intéresser au signal echo, dont il vous faudra mesurer la durée.

Donc .... un autre timer ! Ce sera le timer2.

On souhaite avoir une précision au cm près :

sachant que t(uS)/58 = d(cm), chaque 58µs correspond donc à 1cm.

{{Question|Configurer ce timer pour qu'il déborde toutes les 58µs, et incrémente une variable distance à chaque interruption de débordement}}

On utilisera la broche INT0 pour le signal echo.

{{Question|Écrire un programme qui :}}
*lance le timer1
*répète
**attendre que echo=1
**lancer timer2
**attendre que echo=0
**arrêter timer2
**envoie la distance sur la liaison série
**remettre la distance à 0
**remettre le timer à 0

={{Rouge|Visualisation de la distance}}=

Entre en jeu le servomoteur et sa mli .... et donc le dernier timer disponible : timer0 !
[[File:TiemposServo.svg|TiemposServo]]

=={{Bleu|Test du servo}}==

{{Question|Configurez le timer0 pour générer une MLI sur OCR0A ou OCR0B au choix}}
*la fréquence de MLI a assez peu d'importance
*on souhaite juste un déplacement du servomoteur entre 2 positions

=={{Bleu|Couplage avec mesure de distance}}==

{{Question|Faire en sorte que la position du servomoteur indique la distance mesurée par le capteur ultrason}}

* [https://www.youtube.com/watch?v=rTM5gZxBPmY Vidéo Youtube expliquant ce que l'on cherche à faire]

Cours:TPS 2103 tp evitementObstacles

2019-06-11T07:21:06Z

Ech-01 : Annulation des modifications 11555 de Ech-01 (discussion)

Cours:TPS 2103 tp evitementObstacles

2019-06-11T07:20:50Z

Ech-01 :

Cours:TPS 2103 tp evitementObstacles

2019-06-11T06:58:11Z

Ech-01 : Annulation des modifications 11553 de Ech-01 (discussion)

Cours:TPS 2103 tp evitementObstacles

2019-06-11T06:57:51Z

Ech-01 :

Cours:TPS 2103 tp evitementObstacles

2019-06-11T06:47:08Z

Ech-01 : Annulation des modifications 11550 de Ech-01 (discussion)

Cours:TPS 2103 tp evitementObstacles

2019-06-11T06:46:49Z

Ech-01 :

Cours:TPS 2103 tp mesureDeDistance

2019-06-11T06:42:00Z

Ech-01 : Annulation des modifications 11548 de Ech-01 (discussion)

Cours:TPS 2103 tp mesureDeDistance

2019-06-11T06:41:47Z

Ech-01 :

Cours:TPS 2103 tp evitementObstacles

2019-06-11T06:16:45Z

Ech-01 : Annulation des modifications 11546 de Ech-01 (discussion)

Cours:TPS 2103 tp evitementObstacles

2019-06-11T06:16:24Z

Ech-01 :

Cours:TPS 2103 tp evitementObstacles corr

2019-06-11T06:16:03Z

Ech-01 : Annulation des modifications 11544 de Ech-01 (discussion)

<accesscontrol>Acces:Prof</accesscontrol>

<source lang=c>
/*
* miniQ1.c
*
* Created on: 25 mai 2016
* Author: moutou01
*/
#include <avr/io.h>
#include <avr/interrupt.h>

#undef F_CPU
#define F_CPU 16000000UL
#include <util/delay.h>

#define FORW 1
#define BACK 0

volatile uint8_t count=0,left=1;

ISR(PCINT0_vect)
{
count++;//on incrémente le compteur pour chaque impulsion reçue}
}

void setPCINT0()
{
PCICR = (1<<PCIE0);
PCMSK0 = (1<<PCINT0); //Autorisation de l'interruption INT0

}

ISR(TIMER0_COMPA_vect)
{
if (left)
PORTC ^= (1<<PC7);
else
PORTB ^= (1<<PB4);

}

void initpwm() {
DDRC |= (1<<PC6); // PC6 en sortie : moteur gauche
DDRD |= (1<<PD7); // PD7 en sortie : moteur droit
TCCR4B |= (1<<CS42)|(1<<CS41); // division par 64
// moteur gauche
TCCR4A |= (1<<COM4A0)|(1<<PWM4A); // PWM en et /OC4A
TCCR4E |= (1<<OC4OE0); // 0C4OE0 pour /OC4A
// moteur droit
TCCR4C |= (1<<COM4D1)|(1<<PWM4D); // PWM en et OC4D
TCCR4E |= (1<<OC4OE5); // 0C4OE5 pour OC4D
// pendant qu'on y est on prépare tout pour pouvoir changer de sens
DDRE |= (1<<PE6); // sens moteur droit;
DDRD |= (1<<PD6); // sens moteur gauche
}

void Motor_Control(char MG_DIR,char MG_EN,char MD_DIR,char MD_EN) {
// moteur gauche
if(MG_DIR==FORW)//si vers l'avant
PORTD &=~(1<<PD6);//IN2 passé à 0
else
PORTD |=(1<<PD6);//IN2 passé à 1
OCR4A = 255-MG_EN; // rapport cyclique ou setVitesseG(MG_EN);
// puis moteur droit
if(MD_DIR==FORW)//si vers l'avant
PORTE &=~(1<<PE6);//IN1 passé à 0
else
PORTE |=(1<<PE6);//IN1 passé à 1
OCR4D = MD_EN; // rapport cyclique ou setVitesseD(MD_EN);
}

void setTIMER0_interrupt_ctc() {
// mode CTC (010)
TCCR0B &= ~((1<<WGM02)|(WGM00));
TCCR0A |= (1<<WGM01);
//prediviseur par 1
TCCR0B |= (1<<CS00);
// maxi CTC
OCR0A = 210;
//Autorisation interruption comparaison
TIMSK0 |= (1<<OCIE0A);

}

main() {
uint16_t can8;
// put your setup code here, to run once:
initpwm();
//initCAN8();
setPCINT0();
setTIMER0_interrupt_ctc();
sei();
Motor_Control(FORW,75,FORW,75);//avanti
while(1){
left = 1;
count = 0;
for (uint8_t i=0;i<20;i++) {
_delay_us(300);
// on coupe l'émission en bloquant interruptions
TIMSK0 &= ~(1<<OCIE0A);
_delay_us(600);
// on rememt l'émission en autorisant les interruptions
TIMSK0 |= (1<<OCIE0A);
}// for
if (count > 20) {
Motor_Control(BACK,0,BACK,0);
_delay_ms(1);
Motor_Control(BACK,75,BACK,75);
_delay_ms(400);
Motor_Control(FORW,0,BACK,0);
_delay_ms(1);
Motor_Control(FORW,75,BACK,75);
_delay_ms(200);
}
Motor_Control(FORW,75,FORW,75);//avanti
left = 0;
count = 0;
for (uint8_t i=0;i<20;i++) {
_delay_us(300);
// on coupe l'émission en bloquant interruptions
TIMSK0 &= ~(1<<OCIE0A);
_delay_us(600);
// on rememt l'émission en autorisant les interruptions
TIMSK0 |= (1<<OCIE0A);
}// for
if (count > 20) {
Motor_Control(BACK,0,BACK,0);
_delay_ms(1);
Motor_Control(BACK,75,BACK,75);
_delay_ms(400);
Motor_Control(BACK,0,FORW,0);
_delay_ms(1);
Motor_Control(BACK,75,FORW,75);
_delay_ms(200);
}
Motor_Control(FORW,75,FORW,75);//avanti
}
}
</source>

Cours:TPS 2103 tp evitementObstacles corr

2019-06-11T06:15:24Z

Ech-01 :

<source lang=c>
/*
* miniQ1.c
*
* Created on: 25 mai 2016
* Author: moutou01
*/
#include <avr/io.h>
#include <avr/interrupt.h>

#undef F_CPU
#define F_CPU 16000000UL
#include <util/delay.h>

#define FORW 1
#define BACK 0

volatile uint8_t count=0,left=1;

ISR(PCINT0_vect)
{
count++;//on incrémente le compteur pour chaque impulsion reçue}
}

void setPCINT0()
{
PCICR = (1<<PCIE0);
PCMSK0 = (1<<PCINT0); //Autorisation de l'interruption INT0

}

ISR(TIMER0_COMPA_vect)
{
if (left)
PORTC ^= (1<<PC7);
else
PORTB ^= (1<<PB4);

}

void initpwm() {
DDRC |= (1<<PC6); // PC6 en sortie : moteur gauche
DDRD |= (1<<PD7); // PD7 en sortie : moteur droit
TCCR4B |= (1<<CS42)|(1<<CS41); // division par 64
// moteur gauche
TCCR4A |= (1<<COM4A0)|(1<<PWM4A); // PWM en et /OC4A
TCCR4E |= (1<<OC4OE0); // 0C4OE0 pour /OC4A
// moteur droit
TCCR4C |= (1<<COM4D1)|(1<<PWM4D); // PWM en et OC4D
TCCR4E |= (1<<OC4OE5); // 0C4OE5 pour OC4D
// pendant qu'on y est on prépare tout pour pouvoir changer de sens
DDRE |= (1<<PE6); // sens moteur droit;
DDRD |= (1<<PD6); // sens moteur gauche
}

void Motor_Control(char MG_DIR,char MG_EN,char MD_DIR,char MD_EN) {
// moteur gauche
if(MG_DIR==FORW)//si vers l'avant
PORTD &=~(1<<PD6);//IN2 passé à 0
else
PORTD |=(1<<PD6);//IN2 passé à 1
OCR4A = 255-MG_EN; // rapport cyclique ou setVitesseG(MG_EN);
// puis moteur droit
if(MD_DIR==FORW)//si vers l'avant
PORTE &=~(1<<PE6);//IN1 passé à 0
else
PORTE |=(1<<PE6);//IN1 passé à 1
OCR4D = MD_EN; // rapport cyclique ou setVitesseD(MD_EN);
}

void setTIMER0_interrupt_ctc() {
// mode CTC (010)
TCCR0B &= ~((1<<WGM02)|(WGM00));
TCCR0A |= (1<<WGM01);
//prediviseur par 1
TCCR0B |= (1<<CS00);
// maxi CTC
OCR0A = 210;
//Autorisation interruption comparaison
TIMSK0 |= (1<<OCIE0A);

}

main() {
uint16_t can8;
// put your setup code here, to run once:
initpwm();
//initCAN8();
setPCINT0();
setTIMER0_interrupt_ctc();
sei();
Motor_Control(FORW,75,FORW,75);//avanti
while(1){
left = 1;
count = 0;
for (uint8_t i=0;i<20;i++) {
_delay_us(300);
// on coupe l'émission en bloquant interruptions
TIMSK0 &= ~(1<<OCIE0A);
_delay_us(600);
// on rememt l'émission en autorisant les interruptions
TIMSK0 |= (1<<OCIE0A);
}// for
if (count > 20) {
Motor_Control(BACK,0,BACK,0);
_delay_ms(1);
Motor_Control(BACK,75,BACK,75);
_delay_ms(400);
Motor_Control(FORW,0,BACK,0);
_delay_ms(1);
Motor_Control(FORW,75,BACK,75);
_delay_ms(200);
}
Motor_Control(FORW,75,FORW,75);//avanti
left = 0;
count = 0;
for (uint8_t i=0;i<20;i++) {
_delay_us(300);
// on coupe l'émission en bloquant interruptions
TIMSK0 &= ~(1<<OCIE0A);
_delay_us(600);
// on rememt l'émission en autorisant les interruptions
TIMSK0 |= (1<<OCIE0A);
}// for
if (count > 20) {
Motor_Control(BACK,0,BACK,0);
_delay_ms(1);
Motor_Control(BACK,75,BACK,75);
_delay_ms(400);
Motor_Control(BACK,0,FORW,0);
_delay_ms(1);
Motor_Control(BACK,75,FORW,75);
_delay_ms(200);
}
Motor_Control(FORW,75,FORW,75);//avanti
}
}
</source>

Cours:TPS 2103 tp evitementObstacles corr

2019-06-11T06:15:10Z

Ech-01 : Annulation des modifications 11542 de Ech-01 (discussion)

Cours:TPS 2103 tp evitementObstacles corr

2019-06-11T06:14:44Z

Ech-01 :

Cours:TPS 2103 tp jeuDeMemoire

2019-06-11T06:14:11Z

Ech-01 :

[[Cours:TPs_2103|{{Rouge|<big>'''Retour à la liste des Tps'''</big>}}]]

[[Cours:TPS_2103_tp_jeuDeMemoire_corrige|{{Vert|<big>'''Éléments de correction'''</big>}}]]

{{Rouge|<big>'''!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!'''</big>}}

{{Rouge|<big>'''!!!!! Alimenter les programmateurs en 3.3V !!!!!'''</big>}}

{{Rouge|<big>'''!!!!! pour utiliser les boutons !!!!!'''</big>}}

{{Rouge|<big>'''!!!!! Mettre en 5v pour reprogrammer !!!!!'''</big>}}

{{Rouge|<big>'''!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!'''</big>}}

={{Rouge|Principe de programmation et fusible}}=

Le µcontrôleur utilisé est un attiny10, cadencé à 1MHz.

Il convient de modifier les fusibles du µcontrôleur (configuration du composant : type d'horloge, mode de programmation, verrouillage ...)

{{Todo|La valeur du fusible doit être : 0xFE}}
*soit graphiquement dans eclipse
*soit en ligne de commande
avrdude -c avrisp2 -P usb -p t10 -U fuse:w:0xFE:m

{{Rouge|Remarques :}} Une bonne base de programme est donné ci-dessous.
<source lang=c>
// +====+
// PWMA/PB0 |* | PB3 (RESET)
// GND | | Vcc
// PWMB/PB1 | | PB2 (CLKO)
// +====+

#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>

int main(void)
{

while (1)
{
}
}
</source>

={{Rouge|Explorons les sorties}}=

=={{Bleu|Schéma électrique}}==

Les schémas suivants vous permettent :
*de comprendre sur quel état logique les leds s'allument
*de trouver la liste des sorties
*d'associer chaque led avec un numéro de patte

[[Fichier:simonsay.png]]

{|
|-
|[[Fichier:ATTINY10-pinout.jpg]]
||
Le tableau donne la correspondance entre patte de sortie du µcontrôleur et position de(s) led(s) sur le dé :

{|class="wikitable center"
|-
| PB0 || haut || droite
|-
| PB1 || haut || gauche
|-
| PB2 || bas || gauche
|-
| PB3 || bas || droite
|}
|}

=={{Bleu|Commandez les sorties}}==

Dans cette partie, on demande à avoir le même état sur toutes les leds (allumées ou éteintes).

{{Question|Écrire un programme qui change l'état de toutes les leds toutes les secondes.}}

=={{Bleu|générons une séquence}}==

L'objectif est d'afficher une séquence sur les leds (led0 puis led3 puis led0 ....), on utilisera un tableau.

Plus le niveau atteint sera élevé, plus la séquence sera longue.

<source lang=c>
#define niveauMax 10
unsigned char sequence [niveauMax]= {1,3,1,3,2,0...};
</source>

{{Question|Utiliser ce tableau pour allumer successivement les leds dans l'ordre indiqué.}}

=={{Bleu|motif gagné}}==

On souhaite générer une séquence particulière lorsque le joueur gagne :

les leds s'allument successivement en "tournant" en rond (on fera plusieurs "tours").

{{Question|Implémenter la fonction gagne, dont le prototype est donné ci-dessous :}}
<source lang=c>
inline void gagne () __attribute__((always_inline));

void gagne()
{
}
</source>

=={{Bleu|motif perdu}}==

On souhaite générer une séquence particulière lorsque le joueur perd :

les leds s'allument toutes puis s'éteignent plusieurs fois.

{{Question|Implémenter la fonction perdu, dont le prototype est donné ci-dessous :}}
<source lang=c>
inline void perdu () __attribute__((always_inline));

void perdu()
{
}
</source>

={{Rouge|Et l'entrée ?!}}=

=={{Bleu|Principe}}==

Vous constaterez sur le schéma électrique que les broches du µcontrôleur sont partagées entre bouton et led.

Il faudra donc modifier la valeur du registre DDRB lorsque l'on souhaitera observer l'état des boutons.

On rappelle le rôle du registre PORTx suivant la valeur de DDRx :

{| class="wikitable"
|-
! état d'un bit de DDRx !! rôle du bit de PORTx !! bit de PORTx à '0' !! bit de PORTx à '1'
|-
| '0' || Activer/Désactiver la résistance de PULL-UP || pas de PULL-UP || PULL-UP
|-
| '1' || Modifier l'état de la sortie || sortie à '0' || sortie à '1'
|}

{{Rouge|Ici, pour que le bouton fonctionne correctement, il ne doit pas y avoir de résistance de PULL-UP activée.}}

=={{Bleu|Utilisons les boutons}}==

On souhaite dans un premier temps juste vérifier que les boutons fonctionnent.

{{Question|Écrire un programme qui attend qu'un bouton soit appuyé et alors affiche le motif "gagné".}}

'''Remarques :'''
*il est possible que certains boutons ne fonctionnent pas très bien sur le support de programmation !
*on attendra le relâchement de tous les boutons avant de recommencer.

=={{Bleu|Associons bouton et led}}==

L'objectif étant de reproduire la séquence générée sur les leds, il convient de regarder lequel des boutons est appuyé.

Une variable bp devra correspondre au numéro du bouton appuyé. Il convient sans doute d'utiliser un "switch case".

{{Question|Utiliser cette variable ch, et faire clignoter la led associée au bouton sur lequel on appuie.}}

={{Rouge|Jeu de mémoire}}=

Toutes les briques ou presque sont en place. Il ne manque qu'un peu d'aléatoire que nous ajouterons par la suite.

Réexpliquons le principe du jeu :
*on affiche une séquence aléatoire dont la longueur correspond au niveau
**une seule led si niveau 1
**séquence de 2 leds pour le niveau 2
**séquence de 10 leds pour le niveau 10
*le joueur doit reproduire la séquence
*s'il gagne on augmente le niveau
*s'il perd on recommence au niveau 1

{{Question|Écrire un programme qui répond à ce cahier des charges}}

'''Remarques'''
*attention, des boutons peuvent fonctionner difficilement sur le support
*il faut attendre quelques (30 par ex) ms après appui/relâchement des boutons pour éviter les rebonds (plusieurs appuis)

L'algorithme suivant peut vous aider à écrire votre programme :
*broches en sortie
*répéter tout le temps
**répéter de 0 à niveau
***allumer la led en fonction du tableau de séquence
***attendre 500ms
**broches en entrée pas de pull-up
**variable sequenceOk à 1
**répéter de 0 à niveau
***attendre pas de bouton
***attendre qques ms
***attendre appui
***attendre qques ms
***trouver valeur de bp
***si mauvaise touche
****variable sequenceOk à 0
**broches en sortie
**si sequenceOk
***afficher gagner
***incrementer niveau
**sinon
***afficher perdu
***mettre niveau à 0
**attendre 500ms

={{Rouge|Un peu de hasard}}=

Il suffit maintenant de choisir de façon aléatoire le numéro de la led au lieu d'avoir une valeur prédéfinie.

On utilisera pour cela le timer, qu'il suffira de démarrer et ensuite de lire sa valeur (avec un modulo !).

Pour information, le TIMER0 est un timer 8 bits.

Le tableau donne les valeurs et modes de comptage suivant l'état des bits CS0(0/1/2) du registre {{Rouge|TCCR0B}}

{| class="wikitable"
|-
! CS02 !! CS01 !! CS00 !! Mode !! Fréquence de comptage
|-
| 0 || 0 || 0 || Arrêt || Sans objet
|-
| 0 || 0 || 1 || recopie de l'horloge || Fcpt = Fq
|-
| 0 || 1 || 0 || %8 || Fcpt=Fq/8
|-
| 0 || 1 || 1 || %64 || Fcpt=Fq/64
|-
| 1 || 0 || 0 || %256 || Fcpt=Fq/256
|-
| 1 || 0 || 1 || %1024 || Fcpt=Fq/1024
|-
| 1 || 1 || 0 || Externe || Comptage sur front montant
|-
| 1 || 1 || 1 || Externe || Comptage sur front descendant
|}

L'algorithme précédent est modifié de la sorte :
*lire la valeur du timer (TCNT0)
*écrire la valeur dans le tableau de séquence
*afficher la led correspondante

{{Question|Apporter les modifications à votre programme}}

={{Rouge|Terminé ?}}=

Parfait, vous avez un jeu qui fonctionne. Ne reste plus qu'à limiter la consommation lorsque l'on n'utilise plus le jeu.

Vous vous servirez des fonctions disponibles [http://www.nongnu.org/avr-libc/user-manual/group__avr__sleep.html dans le fichier {{Rouge|avr/sleep.h}}] pour passer en économie d'énergie.

Les différents modes sont détaillés [[media:Attiny10.pdf|Attiny10.pdf]] dans la partie 7. Le tableau donne la correspondance entre le mode de consommation et la valeur à utiliser dans les fonctions du fichier {{Rouge|avr/sleep.h}}.

{{Cours:tabSleepMode}}

Vous configurerez l'interruption associée au bouton poussoir, ce qui permettra de sortir du mode faible consommation. Pour gérer cette interruption, vous regarderez [[media:Attiny10.pdf|la documentation, parties 9.2 et 9.3]].

'''Indication 1''' : Cette interruption '''INT0''' est utilisable pour les quatre modes SLEEP_MODE_IDLE, SLEEP_MODE_ADC, SLEEP_MODE_STANDBY et SLEEP_MODE_PWR_DOWN. Mais elle ne fonctionne que sur un changement de niveau pour les trois derniers modes ! Ne cherchez donc pas à détecter un front.

'''Indication 2''' : Le passage en mode économie d'énergie se fait à l'aide de deux instructions :
<source lang=C>
#include <avr/sleep.h>
....
set_sleep_mode(SLEEP_MODE_IDLE); // sleep mode is set here
sleep_mode(); // le programme s'arrête
</source>

{{Question|Compléter votre programme pour placer votre µcontrôleur dans un mode d'économie d'énergie le plus élevé (plus faible consommation) possible.}}

Cours:TPS 2103 tp jeuDeMemoire corrige

2019-06-11T06:13:51Z

Ech-01 : Annulation des modifications 11539 de Ech-01 (discussion)

<accesscontrol>Acces:Prof</accesscontrol>
[[Cours:TPs_2103|{{Rouge|<big>'''Retour à la liste des Tps'''</big>}}]]

[[Cours:TPS_2103_tp_jeuDeMemoire|{{Vert|<big>'''Énoncé de TP'''</big>}}]]

={{Rouge|pas d'aléatoire}}=

<source lang=c>
// +====+
// PWMA/PB0 |* | PB3 (RESET)
// GND | | Vcc
// PWMB/PB1 | | PB2 (CLKO)
// +====+

#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/sleep.h>
#include <util/delay.h>

#define niveauMax 10
unsigned char sequence [niveauMax]= {1,2,0,2,0,1,2,0,1,0};

inline void gagne () __attribute__((always_inline));
inline void perdu () __attribute__((always_inline));

void gagne()
{
for (uint8_t j=0;j<5;j++)
for (uint8_t i=0;i<4;i++)
{
PORTB = ~(1<<i);
_delay_ms(60);
}
}
void perdu()
{
for (uint8_t j=0;j<10;j++)
{
PORTB ^= 0x0F;
_delay_ms(60);
}
}

int main(void)
{
uint8_t i=0,bp,niveau=1,seqOk=1;
DDRB |= 0x0F;
while (1)
{
for (i=0;i<niveau;i++)
{
PORTB = ~ (1<<sequence[i]);
_delay_ms(500);
}
DDRB=0;
PORTB=0;
seqOk=1;
for (i=0;i<niveau;i++)
{
while(PINB!=0x0F);
_delay_ms(30);
while(PINB==0x0F);
_delay_ms(30);
switch (PINB)
{
case 0b00001110 : bp=0;break;
case 0b00001101 : bp=1;break;
case 0b00001011 : bp=2;break;
case 0b00000111 : bp=3;break;
default : bp=4;break;
}
if (bp!=sequence[i]) seqOk=0;
}
DDRB=0x0F;
if (seqOk==1) {gagne();niveau++;}
else {perdu();niveau=1;}
PORTB=0x0F;
_delay_ms(500);
}
}
</source>

Cours:TPS 2103 tp jeuDeMemoire corrige

2019-06-11T06:13:02Z

Ech-01 :

[[Cours:TPs_2103|{{Rouge|<big>'''Retour à la liste des Tps'''</big>}}]]

[[Cours:TPS_2103_tp_jeuDeMemoire|{{Vert|<big>'''Énoncé de TP'''</big>}}]]

={{Rouge|pas d'aléatoire}}=

<source lang=c>
// +====+
// PWMA/PB0 |* | PB3 (RESET)
// GND | | Vcc
// PWMB/PB1 | | PB2 (CLKO)
// +====+

#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/sleep.h>
#include <util/delay.h>

#define niveauMax 10
unsigned char sequence [niveauMax]= {1,2,0,2,0,1,2,0,1,0};

inline void gagne () __attribute__((always_inline));
inline void perdu () __attribute__((always_inline));

void gagne()
{
for (uint8_t j=0;j<5;j++)
for (uint8_t i=0;i<4;i++)
{
PORTB = ~(1<<i);
_delay_ms(60);
}
}
void perdu()
{
for (uint8_t j=0;j<10;j++)
{
PORTB ^= 0x0F;
_delay_ms(60);
}
}

int main(void)
{
uint8_t i=0,bp,niveau=1,seqOk=1;
DDRB |= 0x0F;
while (1)
{
for (i=0;i<niveau;i++)
{
PORTB = ~ (1<<sequence[i]);
_delay_ms(500);
}
DDRB=0;
PORTB=0;
seqOk=1;
for (i=0;i<niveau;i++)
{
while(PINB!=0x0F);
_delay_ms(30);
while(PINB==0x0F);
_delay_ms(30);
switch (PINB)
{
case 0b00001110 : bp=0;break;
case 0b00001101 : bp=1;break;
case 0b00001011 : bp=2;break;
case 0b00000111 : bp=3;break;
default : bp=4;break;
}
if (bp!=sequence[i]) seqOk=0;
}
DDRB=0x0F;
if (seqOk==1) {gagne();niveau++;}
else {perdu();niveau=1;}
PORTB=0x0F;
_delay_ms(500);
}
}
</source>

Cours:TPS 2103 tp evitementObstacles

2019-06-11T06:05:14Z

Ech-01 : Annulation des modifications 11535 de Ech-01 (discussion)

Cours:TPS 2103 tp jeuDeMemoire

2019-06-11T06:04:59Z

Ech-01 : Annulation des modifications 11534 de Ech-01 (discussion)

<accesscontrol>Acces:Prof</accesscontrol>
[[Cours:TPs_2103|{{Rouge|<big>'''Retour à la liste des Tps'''</big>}}]]

[[Cours:TPS_2103_tp_jeuDeMemoire_corrige|{{Vert|<big>'''Éléments de correction'''</big>}}]]

{{Rouge|<big>'''!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!'''</big>}}

{{Rouge|<big>'''!!!!! Alimenter les programmateurs en 3.3V !!!!!'''</big>}}

{{Rouge|<big>'''!!!!! pour utiliser les boutons !!!!!'''</big>}}

{{Rouge|<big>'''!!!!! Mettre en 5v pour reprogrammer !!!!!'''</big>}}

{{Rouge|<big>'''!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!'''</big>}}

={{Rouge|Principe de programmation et fusible}}=

Le µcontrôleur utilisé est un attiny10, cadencé à 1MHz.

Il convient de modifier les fusibles du µcontrôleur (configuration du composant : type d'horloge, mode de programmation, verrouillage ...)

{{Todo|La valeur du fusible doit être : 0xFE}}
*soit graphiquement dans eclipse
*soit en ligne de commande
avrdude -c avrisp2 -P usb -p t10 -U fuse:w:0xFE:m

{{Rouge|Remarques :}} Une bonne base de programme est donné ci-dessous.
<source lang=c>
// +====+
// PWMA/PB0 |* | PB3 (RESET)
// GND | | Vcc
// PWMB/PB1 | | PB2 (CLKO)
// +====+

#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>

int main(void)
{

while (1)
{
}
}
</source>

={{Rouge|Explorons les sorties}}=

=={{Bleu|Schéma électrique}}==

Les schémas suivants vous permettent :
*de comprendre sur quel état logique les leds s'allument
*de trouver la liste des sorties
*d'associer chaque led avec un numéro de patte

[[Fichier:simonsay.png]]

{|
|-
|[[Fichier:ATTINY10-pinout.jpg]]
||
Le tableau donne la correspondance entre patte de sortie du µcontrôleur et position de(s) led(s) sur le dé :

{|class="wikitable center"
|-
| PB0 || haut || droite
|-
| PB1 || haut || gauche
|-
| PB2 || bas || gauche
|-
| PB3 || bas || droite
|}
|}

=={{Bleu|Commandez les sorties}}==

Dans cette partie, on demande à avoir le même état sur toutes les leds (allumées ou éteintes).

{{Question|Écrire un programme qui change l'état de toutes les leds toutes les secondes.}}

=={{Bleu|générons une séquence}}==

L'objectif est d'afficher une séquence sur les leds (led0 puis led3 puis led0 ....), on utilisera un tableau.

Plus le niveau atteint sera élevé, plus la séquence sera longue.

<source lang=c>
#define niveauMax 10
unsigned char sequence [niveauMax]= {1,3,1,3,2,0...};
</source>

{{Question|Utiliser ce tableau pour allumer successivement les leds dans l'ordre indiqué.}}

=={{Bleu|motif gagné}}==

On souhaite générer une séquence particulière lorsque le joueur gagne :

les leds s'allument successivement en "tournant" en rond (on fera plusieurs "tours").

{{Question|Implémenter la fonction gagne, dont le prototype est donné ci-dessous :}}
<source lang=c>
inline void gagne () __attribute__((always_inline));

void gagne()
{
}
</source>

=={{Bleu|motif perdu}}==

On souhaite générer une séquence particulière lorsque le joueur perd :

les leds s'allument toutes puis s'éteignent plusieurs fois.

{{Question|Implémenter la fonction perdu, dont le prototype est donné ci-dessous :}}
<source lang=c>
inline void perdu () __attribute__((always_inline));

void perdu()
{
}
</source>

={{Rouge|Et l'entrée ?!}}=

=={{Bleu|Principe}}==

Vous constaterez sur le schéma électrique que les broches du µcontrôleur sont partagées entre bouton et led.

Il faudra donc modifier la valeur du registre DDRB lorsque l'on souhaitera observer l'état des boutons.

On rappelle le rôle du registre PORTx suivant la valeur de DDRx :

{| class="wikitable"
|-
! état d'un bit de DDRx !! rôle du bit de PORTx !! bit de PORTx à '0' !! bit de PORTx à '1'
|-
| '0' || Activer/Désactiver la résistance de PULL-UP || pas de PULL-UP || PULL-UP
|-
| '1' || Modifier l'état de la sortie || sortie à '0' || sortie à '1'
|}

{{Rouge|Ici, pour que le bouton fonctionne correctement, il ne doit pas y avoir de résistance de PULL-UP activée.}}

=={{Bleu|Utilisons les boutons}}==

On souhaite dans un premier temps juste vérifier que les boutons fonctionnent.

{{Question|Écrire un programme qui attend qu'un bouton soit appuyé et alors affiche le motif "gagné".}}

'''Remarques :'''
*il est possible que certains boutons ne fonctionnent pas très bien sur le support de programmation !
*on attendra le relâchement de tous les boutons avant de recommencer.

=={{Bleu|Associons bouton et led}}==

L'objectif étant de reproduire la séquence générée sur les leds, il convient de regarder lequel des boutons est appuyé.

Une variable bp devra correspondre au numéro du bouton appuyé. Il convient sans doute d'utiliser un "switch case".

{{Question|Utiliser cette variable ch, et faire clignoter la led associée au bouton sur lequel on appuie.}}

={{Rouge|Jeu de mémoire}}=

Toutes les briques ou presque sont en place. Il ne manque qu'un peu d'aléatoire que nous ajouterons par la suite.

Réexpliquons le principe du jeu :
*on affiche une séquence aléatoire dont la longueur correspond au niveau
**une seule led si niveau 1
**séquence de 2 leds pour le niveau 2
**séquence de 10 leds pour le niveau 10
*le joueur doit reproduire la séquence
*s'il gagne on augmente le niveau
*s'il perd on recommence au niveau 1

{{Question|Écrire un programme qui répond à ce cahier des charges}}

'''Remarques'''
*attention, des boutons peuvent fonctionner difficilement sur le support
*il faut attendre quelques (30 par ex) ms après appui/relâchement des boutons pour éviter les rebonds (plusieurs appuis)

L'algorithme suivant peut vous aider à écrire votre programme :
*broches en sortie
*répéter tout le temps
**répéter de 0 à niveau
***allumer la led en fonction du tableau de séquence
***attendre 500ms
**broches en entrée pas de pull-up
**variable sequenceOk à 1
**répéter de 0 à niveau
***attendre pas de bouton
***attendre qques ms
***attendre appui
***attendre qques ms
***trouver valeur de bp
***si mauvaise touche
****variable sequenceOk à 0
**broches en sortie
**si sequenceOk
***afficher gagner
***incrementer niveau
**sinon
***afficher perdu
***mettre niveau à 0
**attendre 500ms

={{Rouge|Un peu de hasard}}=

Il suffit maintenant de choisir de façon aléatoire le numéro de la led au lieu d'avoir une valeur prédéfinie.

On utilisera pour cela le timer, qu'il suffira de démarrer et ensuite de lire sa valeur (avec un modulo !).

Pour information, le TIMER0 est un timer 8 bits.

Le tableau donne les valeurs et modes de comptage suivant l'état des bits CS0(0/1/2) du registre {{Rouge|TCCR0B}}

{| class="wikitable"
|-
! CS02 !! CS01 !! CS00 !! Mode !! Fréquence de comptage
|-
| 0 || 0 || 0 || Arrêt || Sans objet
|-
| 0 || 0 || 1 || recopie de l'horloge || Fcpt = Fq
|-
| 0 || 1 || 0 || %8 || Fcpt=Fq/8
|-
| 0 || 1 || 1 || %64 || Fcpt=Fq/64
|-
| 1 || 0 || 0 || %256 || Fcpt=Fq/256
|-
| 1 || 0 || 1 || %1024 || Fcpt=Fq/1024
|-
| 1 || 1 || 0 || Externe || Comptage sur front montant
|-
| 1 || 1 || 1 || Externe || Comptage sur front descendant
|}

L'algorithme précédent est modifié de la sorte :
*lire la valeur du timer (TCNT0)
*écrire la valeur dans le tableau de séquence
*afficher la led correspondante

{{Question|Apporter les modifications à votre programme}}

={{Rouge|Terminé ?}}=

Parfait, vous avez un jeu qui fonctionne. Ne reste plus qu'à limiter la consommation lorsque l'on n'utilise plus le jeu.

Vous vous servirez des fonctions disponibles [http://www.nongnu.org/avr-libc/user-manual/group__avr__sleep.html dans le fichier {{Rouge|avr/sleep.h}}] pour passer en économie d'énergie.

Les différents modes sont détaillés [[media:Attiny10.pdf|Attiny10.pdf]] dans la partie 7. Le tableau donne la correspondance entre le mode de consommation et la valeur à utiliser dans les fonctions du fichier {{Rouge|avr/sleep.h}}.

{{Cours:tabSleepMode}}

Vous configurerez l'interruption associée au bouton poussoir, ce qui permettra de sortir du mode faible consommation. Pour gérer cette interruption, vous regarderez [[media:Attiny10.pdf|la documentation, parties 9.2 et 9.3]].

'''Indication 1''' : Cette interruption '''INT0''' est utilisable pour les quatre modes SLEEP_MODE_IDLE, SLEEP_MODE_ADC, SLEEP_MODE_STANDBY et SLEEP_MODE_PWR_DOWN. Mais elle ne fonctionne que sur un changement de niveau pour les trois derniers modes ! Ne cherchez donc pas à détecter un front.

'''Indication 2''' : Le passage en mode économie d'énergie se fait à l'aide de deux instructions :
<source lang=C>
#include <avr/sleep.h>
....
set_sleep_mode(SLEEP_MODE_IDLE); // sleep mode is set here
sleep_mode(); // le programme s'arrête
</source>

{{Question|Compléter votre programme pour placer votre µcontrôleur dans un mode d'économie d'énergie le plus élevé (plus faible consommation) possible.}}

Cours:TPS 2103 tp mesureDeDistance

2019-06-11T06:04:43Z

Ech-01 : Annulation des modifications 11533 de Ech-01 (discussion)

Cours:TPS 2103 tp evitementObstacles

2019-06-11T06:02:19Z

Ech-01 :

Cours:TPS 2103 tp jeuDeMemoire

2019-06-11T06:02:10Z

Ech-01 :

Cours:TPS 2103 tp mesureDeDistance

2019-06-11T06:02:00Z

Ech-01 :

Cours:TPS 2103 tp mesureDeDistance

2019-06-11T05:32:58Z

Ech-01 : Annulation des modifications 11531 de Ech-01 (discussion)

Cours:TPS 2103 tp mesureDeDistance

2019-06-11T05:31:17Z

Ech-01 :