Table des matières

Solution du début du TD promo 2 2024-2025

Ouvrir: https://wokwi.com/projects/413819874692892673

et cliquer sur la petite flèche à droite de Save, puis “save a copy” pour obtenir une autre URL!

TD 1 Informatique Embarquée CESI

Installation de Wokwi2GtkWave

Suivre les instructions de la page: wokwi2gtkwave

Schéma de la carte Arduino UNO R3: https://bvdp.inetdoc.net/files/cesi/Arduino_Uno_Rev3-schematic.pdf

Simulateur de carte Arduino

Nous allons utiliser Wokwi pour développer le programme et l’exécuter sur un simulateur. Nous pourrons utiliser gdb si besoin pour débugger le programme, et pour cela nous utiliserons l'antisèche suivante: https://bvdp.inetdoc.net/files/cesi/Arduino_AVR_GDB_Cheat_Sheet_sans_image_imprim%C3%A9_en2ppf_simplifi%C3%A9_67pourcent.pdf

Commencez par ouvrir une nouvelle fenêtre à l'adresse: https://wokwi.com/

(Vous pourrez passer d'une fenêtre à l'autre avec le raccourci clavier ALT+TAB pour alterner entre le sujet et Wokwi)

Cliquer sur “Arduino Uno” en dessous de “Start from scratch”

Vous obtenez un projet vierge, cliquer sur la flèche rose à droite de “SAVE” puis sur “Save a copy”. Vous obtenez alors dans la barre d'adresse une URL que vous DEVEZ stocker pour pouvoir retrouver vos fichiers. Vos fichiers seront sauvés dans le nuage dès que vous taperez sur CTRL+S après avoir cliqué sur la fenêtre de texte.

En cliquant sur “SIGN IN” en haut à droite, vous pourrez vous connecter à l'aide de votre compte Google par exemple et retrouver plus facilement vos fichiers.

En cliquant sur “DOCS” en haut à droite, vous aurez accès à l'aide de l'outils Wokwi et notamment aux informations sur les composants matériels simulés dans la partie “Diagram Reference”

Nous allons maintenant pouvoir saisir la schématique du projet sur lequel vous allez travailler:

Schéma du montage utilisé dans le TD

Pour reproduire cette schématique dans votre projet, copier coller le contenu du fichier suivant dans l'onglet diagram.json en écrasant le contenu antérieur:

diagram.json
{
  "version": 1,
  "author": "Bertrand Vandeportaele inspired from some Uri Shaked designs'",
  "editor": "wokwi",
  "parts": [
    { "type": "wokwi-arduino-uno", "id": "uno", "top": -41.14, "left": 32.68, "attrs": {} },
    { "type": "wokwi-74hc165", "id": "sr1", "top": -121.05, "left": 145.07, "attrs": {} },
    { "type": "wokwi-slide-switch", "id": "sw8", "top": -201.18, "left": 0, "attrs": {} },
    { "type": "wokwi-slide-switch", "id": "sw7", "top": -201.18, "left": 40, "attrs": {} },
    { "type": "wokwi-slide-switch", "id": "sw6", "top": -201.18, "left": 80, "attrs": {} },
    { "type": "wokwi-slide-switch", "id": "sw5", "top": -201.18, "left": 120, "attrs": {} },
    { "type": "wokwi-slide-switch", "id": "sw4", "top": -201.18, "left": 160, "attrs": {} },
    { "type": "wokwi-slide-switch", "id": "sw3", "top": -201.18, "left": 200, "attrs": {} },
    { "type": "wokwi-slide-switch", "id": "sw2", "top": -201.18, "left": 240, "attrs": {} },
    { "type": "wokwi-slide-switch", "id": "sw1", "top": -201.18, "left": 280, "attrs": {} },
    {
      "type": "wokwi-74hc595",
      "id": "sr2",
      "top": -302.5,
      "left": 313.3,
      "rotate": 90,
      "attrs": {}
    },
    {
      "type": "wokwi-led",
      "id": "led1",
      "top": -335,
      "left": 275,
      "attrs": { "color": "red", "label": "0" }
    },
    {
      "type": "wokwi-led",
      "id": "led2",
      "top": -335,
      "left": 235,
      "attrs": { "color": "red", "label": "1" }
    },
    {
      "type": "wokwi-led",
      "id": "led3",
      "top": -335,
      "left": 195,
      "attrs": { "color": "red", "label": "2" }
    },
    {
      "type": "wokwi-led",
      "id": "led4",
      "top": -335,
      "left": 155,
      "attrs": { "color": "red", "label": "3" }
    },
    {
      "type": "wokwi-led",
      "id": "led5",
      "top": -335,
      "left": 115,
      "attrs": { "color": "red", "label": "4" }
    },
    {
      "type": "wokwi-led",
      "id": "led6",
      "top": -335,
      "left": 75,
      "attrs": { "color": "red", "label": "5" }
    },
    {
      "type": "wokwi-led",
      "id": "led7",
      "top": -335,
      "left": 35,
      "attrs": { "color": "red", "label": "6" }
    },
    {
      "type": "wokwi-led",
      "id": "led8",
      "top": -335,
      "left": -5,
      "attrs": { "color": "red", "label": "7" }
    },
    {
      "type": "wokwi-led",
      "id": "led9",
      "top": 205,
      "left": 20,
      "attrs": { "color": "green", "label": "8" }
    },
    {
      "type": "wokwi-slide-potentiometer",
      "id": "pot1",
      "top": 193.07,
      "left": 122.96,
      "attrs": { "travelLength": "30" }
    },
    {
      "type": "wokwi-resistor",
      "id": "r1",
      "top": 273.64,
      "left": 35.51,
      "attrs": { "value": "220" }
    },
    {
      "type": "wokwi-pushbutton",
      "id": "btn1",
      "top": 214.91,
      "left": 360.59,
      "attrs": { "bounce": "0", "color": "green", "label": "INT0" }
    }
  ],
  "connections": [
    [ "sr1:D7", "sw8:2", "green", [ "v24", "h-114" ] ],
    [ "sr1:D6", "sw7:2", "green", [ "v18", "h-114" ] ],
    [ "sr1:D5", "sw6:2", "green", [ "v12", "h-80" ] ],
    [ "sr1:D4", "sw5:2", "green", [ "v8", "h-45" ] ],
    [ "sr1:D3", "sw4:2", "green", [ "v-26", "h7" ] ],
    [ "sr1:D2", "sw3:2", "green", [ "v-20", "h21" ] ],
    [ "sr1:D1", "sw2:2", "green", [ "v-16", "h61" ] ],
    [ "sr1:D0", "sw1:2", "green", [ "v-10", "h82" ] ],
    [ "sr1:PL", "uno:4", "orange", [ "v36", "h13" ] ],
    [ "sr1:CP", "uno:8", "purple", [ "v30", "h-22" ] ],
    [ "sr1:Q7", "uno:9", "magenta", [ "v-4", "h0" ] ],
    [ "uno:GND.1", "sw8:1", "black", [ "v-16", "h0" ] ],
    [ "sw8:1", "sw7:1", "black", [ "v7", "h0" ] ],
    [ "sw7:1", "sw6:1", "black", [ "v7", "h0" ] ],
    [ "sw6:1", "sw5:1", "black", [ "v7", "h0" ] ],
    [ "sw5:1", "sw4:1", "black", [ "v7", "h0" ] ],
    [ "sw4:1", "sw3:1", "black", [ "v7", "h0" ] ],
    [ "sw3:1", "sw2:1", "black", [ "v7", "h0" ] ],
    [ "sw2:1", "sw1:1", "black", [ "v7", "h0" ] ],
    [ "sw1:3", "uno:5V", "red", [ "v12", "h21", "v335", "h0" ] ],
    [ "sw1:3", "sw2:3", "red", [ "v12", "h0" ] ],
    [ "sw2:3", "sw3:3", "red", [ "v12", "h0" ] ],
    [ "sw3:3", "sw4:3", "red", [ "v12", "h0" ] ],
    [ "sw4:3", "sw5:3", "red", [ "v12", "h0" ] ],
    [ "sw5:3", "sw6:3", "red", [ "v12", "h0" ] ],
    [ "sw6:3", "sw7:3", "red", [ "v12", "h0" ] ],
    [ "sw7:3", "sw8:3", "red", [ "v12", "h0" ] ],
    [ "sr1:VCC", "sw5:3", "red", [ "v-34", "h165" ] ],
    [ "sr1:CE", "sw4:1", "black", [ "v-39", "h158" ] ],
    [ "sr1:GND", "uno:GND.1", "black", [ "v42", "h-233" ] ],
    [ "sr2:GND", "uno:GND.1", "black", [ "v205", "h0" ] ],
    [ "sr2:GND", "led1:C", "black", [ "v0", "h-13" ] ],
    [ "sr2:GND", "led2:C", "black", [ "v0", "h-29" ] ],
    [ "sr2:GND", "led3:C", "black", [ "v0", "h-16" ] ],
    [ "sr2:GND", "led4:C", "black", [ "v0", "h-35" ] ],
    [ "sr2:GND", "led5:C", "black", [ "v0", "h-66" ] ],
    [ "sr2:GND", "led6:C", "black", [ "v0", "h-100" ] ],
    [ "sr2:GND", "led7:C", "black", [ "v0", "h206" ] ],
    [ "sr2:GND", "led8:C", "black", [ "v0", "h277" ] ],
    [ "sr2:DS", "uno:5", "blue", [ "h16", "v220", "h-68" ] ],
    [ "uno:GND.1", "sr2:OE", "black", [ "h0", "v-16", "h230", "v-52" ] ],
    [ "sr2:STCP", "uno:7", "purple", [ "h7", "v189", "h-77" ] ],
    [ "sr2:SHCP", "uno:6", "gray", [ "h4", "v170", "h-66" ] ],
    [ "sr2:Q7", "led8:A", "green", [ "h0" ] ],
    [ "sr2:Q6", "led7:A", "green", [ "h-4", "v6", "h-194" ] ],
    [ "sr2:Q5", "led6:A", "green", [ "h-7", "v12", "h-161" ] ],
    [ "sr2:Q4", "led5:A", "green", [ "h-10", "v18", "h-131" ] ],
    [ "sr2:Q3", "led4:A", "green", [ "h-13", "v24", "h-95" ] ],
    [ "sr2:Q2", "led3:A", "green", [ "h-16", "v31", "h-64" ] ],
    [ "sr2:Q1", "led2:A", "green", [ "h-19", "v37", "h-40" ] ],
    [ "sr2:Q0", "led1:A", "green", [ "h10", "v-17", "h-63", "v40", "h-6" ] ],
    [ "pot1:VCC", "uno:5V", "red", [ "h-3.24", "v-57.95", "h71.45" ] ],
    [ "pot1:SIG", "uno:A0", "purple", [ "h-17.53", "v-68.46", "h135.75" ] ],
    [ "led9:C", "r1:1", "green", [ "v0" ] ],
    [ "uno:GND.3", "pot1:GND", "black", [ "v48.24", "h0.92" ] ],
    [ "pot1:GND", "btn1:2.l", "black", [ "v0" ] ],
    [ "uno:2", "btn1:1.l", "green", [ "v39.33", "h90.26" ] ],
    [ "led9:A", "uno:5V", "red", [ "v10.49", "h39.78", "v-82.47", "h106.04" ] ],
    [ "uno:3", "r1:2", "green", [ "v244.86", "h-161.76", "v4.71" ] ]
  ]
}

Composant afficheur 7 segments supplémentaire pour l'exercice 3

Copiez coller le contenu suivant à partir de la fin de la ligne 107 de diagram.json dans la section “parts”:

diagram_parts.json
,
    {
      "type": "wokwi-7segment",
      "id": "sevseg1",
      "top": -309.66,
      "left": -56.99,
      "attrs": { "common": "cathode" }
    }

Puis copiez coller le contenu suivant à partir de la fin de la ligne 175 de diagram.json dans la section “connections”:

diagram_connections.json
,
    [ "sevseg1:COM.1", "sr2:GND", "black", [ "v10", "h0.85" ] ],
    [ "sevseg1:COM.2", "sr2:GND", "black", [ "v-30", "h0.85" ] ],
    [ "sevseg1:A", "led1:A", "purple", [ "v-30", "h333.91" ] ],
    [ "sevseg1:B", "led2:A", "purple", [ "v-30", "h285.64" ] ],
    [ "sevseg1:C", "led3:A", "purple", [ "v10", "h255.25" ] ],
    [ "sevseg1:D", "led4:A", "purple", [ "v10", "h3" ] ],
    [ "sevseg1:E", "led5:A", "purple", [ "v10", "h3" ] ],
    [ "sevseg1:F", "led6:A", "purple", [ "v-30", "h3" ] ],
    [ "sevseg1:G", "led7:A", "purple", [ "v-30", "h3" ] ],
    [ "sevseg1:DP", "led8:A", "purple", [ "v10", "h46.31" ] ]

Vous devriez voir le composant ajouté à gauche des LED du port de sortie comme visible sur l'image suivante:

Importation de la librairie HAL pour les ports d'entrée sortie

Pour pouvoir utiliser les ports d'entrée sortie, vous allez devoir intégrer au projet les 2 fichiers de librairie suivants. Pour cela, cliquer sur la flèche à droite de diagram.json puis sur “New file” et saisir lib_io_tp.h

Recopier le contenu de ce fichier:

lib_io_tp.h
/*! \file lib_io_tp.h
    \brief Premier TD pour le CESI.
    \author Bertrand Vandeportaele IUT GEII
    \date  28/10/2021
*/ 
#include <Arduino.h>
void SetupES(void);
unsigned char readPort(void);
void writePort(unsigned char value);

Ensuite, cliquer sur la flèche à droite de lib_io_tp.h puis sur “New file” et saisir lib_io_tp.cpp

Recopier le contenu de ce fichier (et lire les commentaires des fonctions pour en comprendre le rôle et l'utilisation):

lib_io_tp.cpp
/*! \file lib_io_tp.cpp
    \brief Premier TD pour le CESI.
    \author Bertrand Vandeportaele IUT GEII
    \date  28/10/2021
*/ 
#include "lib_io_tp.h"
//Librairie pour registres à décalage sur Wokwi.com
/*mix de 
https://wokwi.com/arduino/projects/313005664351814210
et de
https://wokwi.com/arduino/projects/301188813482361352
*/
// Pin definitions:
const int datapin_in = 9;   /* Q7 */
const int clockpin_in =  8;  /* CP */
const int latchpin_in = 4;  /* PL */
const int datapin_out = 5; 
const int clockpin_out = 6;
const int latchpin_out = 7;
/////////////////////////////////////////////////////// 
/*!
 * \brief Fonction d'initialisation des ressources matérielles pour accéder aux ports d'entrée/sortie
*/
void SetupES(void){
  pinMode(datapin_in, INPUT);
  pinMode(clockpin_in, OUTPUT);
  pinMode(latchpin_in, OUTPUT);
  // Set the three SPI pins to be outputs:
  pinMode(datapin_out, OUTPUT);
  pinMode(clockpin_out, OUTPUT);  
  pinMode(latchpin_out, OUTPUT);  
  readPort();
  writePort(0);
  }
///////////////////////////////////////////////////////
/*! \fn unsigned char readPort(void)
    \brief Fonction de lecture du port d'entrée
    \return valeur 8 bits lue sur le port
*/
unsigned char readPort(void){
unsigned char val=0;
// Step 1: Sample
  digitalWrite(latchpin_in, LOW);
  digitalWrite(latchpin_in, HIGH);
  for (int i = 0; i < 8; i++) {
    int bit = digitalRead(datapin_in);
    val=(val<<1)|bit;
    digitalWrite(clockpin_in, HIGH); // Shift out the next bit
    digitalWrite(clockpin_in, LOW);
  }
  return val;
}
///////////////////////////////////////////////////////
/*!
 * \brief Fonction d'écriture vers le port de sortie
 * @param value valeur 8 bits à écrire sur le port
*/
void writePort(unsigned char value){
  shiftOut(datapin_out, clockpin_out, MSBFIRST, value); //Send "data" to the shift register
  //Toggle the latchpin_out to make "data" appear at the outputs
  digitalWrite(latchpin_out, HIGH); 
  digitalWrite(latchpin_out, LOW); 
}
///////////////////////////////////////////////////////

Fichier de départ

Cliquer sur l'onglet sketch.ino et recopier le contenu de ce fichier en écrasant le contenu antérieur:

cesi1.videpouretudiant
/*! \file cesi1.ino
    \brief Premier TD pour le CESI.
    \author Bertrand Vandeportaele IUT GEII
    \date  28/10/2021
*/ 
#include "lib_io_tp.h"
/** Variable globale indiquant la broche Arduino connectée à la LED */
const unsigned int LEDPIN=3;
/** Variable globale indiquant la broche Arduino connectée au bouton poussoir */
const unsigned int BUTTONPIN=2;
/** Variable globale permettant de stocker la dernière valeur écrite sur le 
    port de sortie, pour pouvoir en modifier uniquement certains bits */
unsigned char imageSortie=0;   
//-------------------------------------------------------------------
/*! \fn void setup()
    \brief Initialisation des périphériques et des variables globales
*/
void setup() {
//-------------------------------------------------------------------
//            CODE A COMPLETER PAR LES ETUDIANTS
//-------------------------------------------------------------------
}
//-------------------------------------------------------------------
/*!
 * \fn void loop()
 * \brief La fonction loop doit appeler une seule fonction exo... à la 
 * fois, vous devez conserver le code de tous les exercices mais n'en 
 * utiliser qu'un à la fois
*/
void loop() {
//-------------------------------------------------------------------
//            CODE A COMPLETER PAR LES ETUDIANTS
//-------------------------------------------------------------------
}
//-------------------------------------------------------------------
/*!
 * \fn void exo1()
 * \brief Exercice 1:
 * Vous devez piloter le port de sortie en recopiant l'état du port 
 * entrée et afficher sur la console série en héxadécimal la valeur lue 
 * sur le port d'entrée
 * Utilisez les fonctions void SetupES(void); unsigned char readPort(void); 
 * et void writePort(unsigned char value); de lib_io_tp.h
 * Configurez et utiliser l'interface de communication Série/USB
 * https://www.arduino.cc/reference/en/language/functions/communication/serial
 * https://www.arduino.cc/reference/en/language/functions/communication/serial/print/
 * https://www.arduino.cc/reference/en/language/functions/communication/serial/println/
*/
void exo1(){
//-------------------------------------------------------------------
//            CODE A COMPLETER PAR LES ETUDIANTS
//-------------------------------------------------------------------
}
//-------------------------------------------------------------------
/*!
 * \fn void exo2()
 * \brief Exercice 2:
 * Vous devez piloter le port de sortie en recopiant l'entrée 7 sur la 
 * sortie dont le numéro est défini par entree(2..0)
*/
void exo2(){
//-------------------------------------------------------------------
//            CODE A COMPLETER PAR LES ETUDIANTS
//-------------------------------------------------------------------
}
//-------------------------------------------------------------------
/*!
 * \fn void exo3()
 * \brief Exercice 3:
 * Vous devez piloter le port de sortie pour réaliser le transcodage de la 
 * valeur 4 bits lues sur entrée(3..0) vers les 7 bits du port de sortie 
 * (6..0) en utilisant le     tableau tab fourni,
 * puis ajouter le pilotage de la sortie 7 avec l'entrée 7
*/
void exo3(){
  byte tab[]={0x3f,0x06,0x5b,0x4F,0x66,0x6d,0x7d,0x07,0x7f,0x6f,0x77,0x7c,0x39,0x5e,0x79,0x71};
//-------------------------------------------------------------------
//            CODE A COMPLETER PAR LES ETUDIANTS
//-------------------------------------------------------------------
}
//-------------------------------------------------------------------
/*!
 * \fn void exo4()
 * \brief Exercice 4:
 * Vous devez configurer les entrées sorties numériques de l'arduino numéro 
 * BUTTONPIN et LEDPIN, puis effectuer la recopie de l'entrée BUTTONPIN sur la 
 * sortie LEDPIN en boucle.  
 * https://www.arduino.cc/reference/en/language/functions/digital-io/pinmode/
 * https://www.arduino.cc/reference/en/language/functions/digital-io/digitalread/
 * https://www.arduino.cc/reference/en/language/functions/digital-io/digitalwrite/
*/
void exo4(){
//-------------------------------------------------------------------
//            CODE A COMPLETER PAR LES ETUDIANTS
//-------------------------------------------------------------------
}
//-------------------------------------------------------------------
/*!
 * \fn void exo5()
 * \brief Exercice 5:
 * Vous devez configurer l'entrée analogique A0  puis effectuer la commande du 
 * port de sortie pour qu'une seule LED s'allume à la position approximative du 
 * potentiomètre.
 * https://www.arduino.cc/reference/en/language/functions/analog-io/analogRead/
*/
void exo5(){
//-------------------------------------------------------------------
//            CODE A COMPLETER PAR LES ETUDIANTS
//-------------------------------------------------------------------
}
//-------------------------------------------------------------------
/*!
 * \fn void exo6()
 * \brief Exercice 6:
 * Vous devez configurer l'entrée analogique A0  puis effectuer la commande de 
 * la LED connecté à la sortie LEDPIN afin qu'elle clignote à une fréquence 
 * pilotée par le potentiomètre. La commande de la durée des états hauts et bas 
 * de la sortie LEDPIN sera gérée à l'aide d'une fonction d'attente bloquante delay: 
 * https://www.arduino.cc/reference/en/language/functions/time/delay/
*/
void exo6(){
//-------------------------------------------------------------------
//            CODE A COMPLETER PAR LES ETUDIANTS
//-------------------------------------------------------------------
}
//-------------------------------------------------------------------
/*!
 * \fn void exo7()
 * \brief Exercice 7:
 * Vous devez configurer l'entrée analogique A0  puis effectuer la commande de 
 * la LED connecté à la sortie LEDPIN afin qu'elle clignote avec un rapport cyclique 
 * piloté par le potentiomètre. La commande de la durée des états hauts et bas de 
 * la sortie LEDPIN sera cette fois ci gérée à l'aide d'une sortie PWM (la broche 
 * LEDPIN est compatible PWM) à l'aide de la fonction analogWrite() : 
 * https://www.arduino.cc/reference/en/language/functions/analog-io/analogWrite/
*/
void exo7(){
//-------------------------------------------------------------------
//            CODE A COMPLETER PAR LES ETUDIANTS
//-------------------------------------------------------------------
}
//-------------------------------------------------------------------
/*!
 * \fn void exo8()
 * \brief Exercice 8:
 * Vous devez combiner les exercices 1 et 6 en utilisant une durée de 2 secondes 
 * pour les états hauts et bas du signal pilotant la sortie LEDPIN. Faire en sorte 
 * que la fonction génère une demi période du signal carré. Constatez si 
 * le port de sortie est mis à jour instantanément lorsque le port d'entrée est 
 * modifié.
*/
void exo8(){
//-------------------------------------------------------------------
//            CODE A COMPLETER PAR LES ETUDIANTS
//-------------------------------------------------------------------
}
//-------------------------------------------------------------------
/*!
 * \fn void exo9()
 * \brief Exercice 9:
 * Vous devez modifier l'exercice 8 pour faire en sorte que la recopie du port 
 * d'entrée se fasse sur le port de sortie en permanence. Pour cela utiliser une 
 * fonction non bloquante pour gérer la temporisation à l'aide d'un timer par 
 * scrutation: 
 * https://www.arduino.cc/reference/en/language/functions/time/millis/
*/
void exo9(){
//-------------------------------------------------------------------
//            CODE A COMPLETER PAR LES ETUDIANTS
//-------------------------------------------------------------------
}
//-------------------------------------------------------------------
/*!
 * \fn void exo10()
 * \brief Exercice 10:
 * Découverte du pseudo parallélisme: Dans un premier temps exo10 appelle juste 
 * la fonction tache1() puis réalise une attente bloquante de 500ms.
*/
void exo10(){
//-------------------------------------------------------------------
//            CODE A COMPLETER PAR LES ETUDIANTS
//-------------------------------------------------------------------
}
//-------------------------------------------------------------------
/*!
 * \fn void tache1()
 * \brief tache1:
 * Découverte du pseudo parallélisme: la tache 1 consiste à réaliser un compteur 
 * sur 4 bits sur les bits (3..0) du port de sortie. La valeur maximale prise par 
 * ce compteur est réglé par les bits (3..0) du port d'entrée. "t1" doit être 
 * affiché dans la console série.
*/
void tache1(){
//-------------------------------------------------------------------
//            CODE A COMPLETER PAR LES ETUDIANTS
//-------------------------------------------------------------------
}
//-------------------------------------------------------------------
/*!
 * \fn void exo11()
 * \brief Exercice 11:
 * Découverte du pseudo parallélisme: Dans un second temps exo11 appelle les 
 * fonctions tache1() et  tache2() puis réalise une attente bloquante de 500ms.
*/
void exo11(){
//-------------------------------------------------------------------
//            CODE A COMPLETER PAR LES ETUDIANTS
//-------------------------------------------------------------------
}
//-------------------------------------------------------------------
/*!
 * \fn void tache2()
 * \brief tache2:
 * Découverte du pseudo parallélisme: la tache 2 consiste à réaliser un 
 * chenillard sur 4 bits sur les bits (7..4) du port de sortie. 4 séquences 
 * différentes sont définies dans les tableaux tab1 à 4 fournis. Le choix de 
 * la séquence utilisée est réalisé à l'aide des bits d'entrées (6..5). Si le 
 * bit d'entrée 4 est à 0 alors la séquence est mise en pause. "t2" doit être 
 * affiché dans la console série.
*/
void tache2(){
byte tab1[]={0x1,0x2,0x4,0x8,0x4,0x2};
byte tab2[]={0x1,0x3,0x7,0xf,0x7,0x3};
byte tab3[]={0x8,0xC,0xE,0xf,0xC,0x8};
byte tab4[]={0x8,0x1,0x4,0x2,0x1,0x4};
//-------------------------------------------------------------------
//            CODE A COMPLETER PAR LES ETUDIANTS
//-------------------------------------------------------------------
}
//-------------------------------------------------------------------
/*!
 * \fn void exo12()
 * \brief Exercice 12:
 * Découverte du pseudo parallélisme: la tache1 doit être réalisée toutes les 
 * 500ms et la tache2 doit être réalisée toutes les Nms, N étant la valeur sur 
 * 10bits lue sur l'entrée analogique 0.
*/
void exo12(){
//-------------------------------------------------------------------
//            CODE A COMPLETER PAR LES ETUDIANTS
//-------------------------------------------------------------------
}
//-------------------------------------------------------------------
/*!
 * \fn void exo13()
 * \brief Exercice 13:
 * Gestion d'une interruption matérielle: ajouter à l'exo12 la commande de la 
 * commutation de la LED connectée à LEDPIN par l'appui sur le bouton poussoir 
 * connecté à BUTTONPIN. Pour cela vous utiliserez une interruption sur front sur un broche. 
 * La liste des vecteurs d'interruption est visible en page 49 de  
 * https://ww1.microchip.com/downloads/en/DeviceDoc/Atmel-7810-Automotive-Microcontrollers-ATmega328P_Datasheet.pdf 
 * vous utiliserez external interrupt en page 53, BUTTONPIN doit être égal à 2 
 * car c'est uniquement cette broche qui peut déclencher cette interruption.
*/
void exo13(){
exo12();
}
//-------------------------------------------------------------------
//            CODE A COMPLETER PAR LES ETUDIANTS
//-------------------------------------------------------------------

Compléter ce fichier exercice par exercice en utilisant les commentaires comme consignes.

Pendant la séance, pensez régulièrement à cliquer sur “Save” pour sauvegarder votre projet. En fin de séance, penser à récupérer le texte de votre programme sur en local votre ordinateur et à mémoriser l'URL pour pouvoir retrouver votre projet à la prochaine séance.

Documentation sur l'outils de documentation Doxygen

https://www.doxygen.nl/manual/starting.html

https://www.doxygen.nl/manual/docblocks.html

https://www.doxygen.nl/manual/doxygen_usage.html

https://www.doxygen.nl/manual/config.html#:~:text=The%20format%20is%20ext%3Dlanguage,free%20formatted%20Fortran%3A%20FortranFree%2C%20unknown

https://franckh.developpez.com/tutoriels/outils/doxygen/

Utilisation de Doxygen pour ce projet

Dans le dossier des fichiers source, taper pour générer le fichier de configuration de la doc: 

doxygen -g

Editer le fichier de configuration Doxyfile 

gedit Doxyfile &

Régler: 

FILE_PATTERNS          =  *.cpp *.h *.ino
EXTRACT_ALL=YES
EXTENSION_MAPPING      = ino=C++

Eventuellement, pour générer les graphes d'appels, activer également 

CALL_GRAPH = YES
CALLER_GRAPH = YES

Pour compiler la doc et l'ouvrir dans un browser 

doxygen Doxyfile && chromium-browser html/index.html

Lien vers la documentation généré pour les fichiers du td: cesi1_8ino.html

Annexes

Jeu d'instruction du ATMEGA 328P: https://bvdp.inetdoc.net/files/cesi/AVR-InstructionSet-Manual-DS40002198.pdf

Datasheet du ATMEGA 328P: https://bvdp.inetdoc.net/files/cesi/Atmel-7810-Automotive-Microcontrollers-ATmega328P_Datasheet.pdf