Cours:TDS 2103 mini projet

De troyesGEII
Aller à : navigation, rechercher
ArduinoPinout.png

On souhaite réaliser un système permettant de mesurer le temps de réaction à un événement.

Le principe sera le suivant :

  • une led s'allume
  • on lance un chronomètre (.... oh un timer !)
  • on attend l'appui sur un bouton
  • on affiche le temps de réaction

Le système sera simulé sur Tinkercad et l'utilisation des fonctions arduino .... interdites bien évidemment.

*******************************************
Astuce Tinkercad circuit : 
mettre un _delay_ms(xxx) dans le while(1)
On évitera ainsi :
while( bit_is_set(PINB,PB2) );
qu'on remplacera par :
while( bit_is_set(PINB,PB2) ) _delay_ms(1);
*******************************************


*****************************************
*****************************************
*****************************************
*** feuille de calcul pour les TIMERS ***
*****************************************
*****************************************
*****************************************

Mise sous tension

Commençons par indiquer que le système est vivant.

On branche une led (verte de préférence) sur une broche du port B qui soit pilotée directement par le TIMER1 ... donc pas n'importe laquelle.

Bluebg.png
Aidesmall.png
À propos de cette image

Un peu d'aide ???



  • ça commence par OnCompare
  • ça continue avec le numéro du timer
  • ça se termine par A ou B ... ici on prend la sortie A

Todo.jpg A trouver sur l'image un peu plus haut et câbler cette led sur Tinkercad circuit : montage anodes communes svp

......

Todo.jpg Bon alors, elle fonctionne cette led ???? ... elle s'éclaire trop ou pas assez, la résistance !!!!


Allez, on fait clignoter cette led :

  • rythme 4Hz
    • allumée 4 fois en 1 seconde
    • éteinte 4 fois en 1 seconde
  • temps allumé = temps éteint
  • pas le droit à toute forme de .... delay

Et voilà le premier Timer à configurer :

  • choix du prédiviseur
  • mode CTC
  • valeur de comparaison
  • module de sortie (demander le chgt d'état de OC1A à chaque comparaison)
Documentation simple du Timer 1 (16 bits)
La comparaison avec le Timer 1 (16 bits)


Question.jpg Vérifier le bon fonctionnement du clignotement

Afficheurs

Commençons la partie affichage. Il s'agit de pouvoir indiquer le temps de réaction qui sera affiché en ms. Une valeur typique se situe autour de 200ms.

On pourra réaliser au choix un afficheur sur 3 ou 4 digits permettant d'afficher un temps maximum de 999ms ou 9999ms.

Todo.jpg Réaliser le câblage de ces afficheurs cathodes communes:

  • les segments seront connectés sur le PORTD
  • le point est non utilisé
  • les commandes des transistors de multiplexage (N-MOS) seront reliées sur le PORTC

Todo.jpg Faire et vérifier un tableau de transcodage (cf td précédent)


Et nous voici arrivé au 2ème timer, le TIMER0 :

  • mode CTC
  • interruption de comparaison toutes les 4ms

Question.jpg Configurer le timer et écrire la fonction d'interruption permettant de multiplexer les afficheurs


Documentation simple du Timer 0 (8 bits)
La comparaison avec le Timer 0 (8 bits)

Gestion du bouton

Ça va être rapide :

Question.jpg Ajouter un bouton !

Chronomètre

et de 3 :

Question.jpg Configurer le TIMER2 :

  • mode CTC
  • interruption toutes les 1ms
  • incrémenter un chronomètre à chaque interruption

On réalise ici le chronomètre : si le timer2 est en route (prédiviseur!=0) alors une variable chronomètre s'incrémente toutes les 1 ms.

Question.jpg Faire en sorte que la valeur du chronomètre s'affiche sur les afficheurs

Documentation simple du Timer 2 (8 bits)
La comparaison avec le Timer 2 (8 bits)

Relions l'ensemble

Toutes les briques sont en place, il suffit de :

  • attendre qques secondes
  • mettre en route le timer de comptage (prédiviseur) => le chronomètre se déclenche
  • attendre appui sur bouton ( while (....);)
  • arrêter le timer de comptage (prédiviseur=0)
  • attendre qques seconde
  • recommencer


Question.jpg Codez

Supplément

Todo.jpg gestion du score : gagne 1 pt si temps<150ms

Todo.jpg ajouter 2 afficheurs multiplexés pour afficher le score