Outils pour utilisateurs

Outils du site


cesitd1

TD 1 Informatique Embarquée CESI

Installation de Wokwi-GtkWave pour Windows

Créer un dossier wokwi dans votre dossier utilisateur, C:\Users\“votrelogin”, pour avoir C:\Users\“votrelogin”\wokwi

Téléchargent des fichiers

Si vous n'avez pas python, le télécharger et l'installer. à l'installation, cocher “add to PATH”: https://bvdp.inetdoc.net/files/cesi/gtkwave/python-3.8.6-amd64.exe

Télécharger et dézipper ce fichier dans C:\Users\“votrelogin”\wokwi: https://bvdp.inetdoc.net/files/cesi/gtkwave/gtkwave-3.3.100-bin-win32.zip

Télécharger dans C:\Users\“votrelogin”\wokwi: https://raw.githubusercontent.com/bvandepo/wokwi2gtkwave/main/wokwi2gtkwave.py

En cas de problème, télécharger cette ancienne version: https://bvdp.inetdoc.net/files/cesi/gtkwave/versionwindows/wokwi2gtkwave.py

Configuration de Firefox pour la sauvegarde automatique des fichiers dans le dossier de téléchargement

Saisir l'url suivante dans Firefox: about:config

Cliquer sur “accepter les risques et poursuivre”

Dans la zone recherche un nom de préférence, copier: browser.helperApps.neverAsk.saveToDisk

Cliquer sur le petit stylo (Modifier), puis coller dans la zone de texte: application/octet-stream

Et cliquer sur le V bleu pour valider, puis fermer cet onglet

Lancement de Wokwi-GtkWave pour Windows

A chaque séance, vous devrez lancer une fois l'application de la manière suivante:

presser touche Windows +R, puis taper cmd et “entrée”, puis copier coller les lignes suivantes:

echo commence
cd C:\Users\%username%\wokwi
python wokwi2gtkwave.py                 
echo fini

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.

Pour cela ouvrir dans un nouvel onglet: https://wokwi.com/

Cliquer sur “Arduino Uno” en dessous de “Start a New Project”

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);  
  }
///////////////////////////////////////////////////////
/*! \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 broche. 
 * La liste des vecteur 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
//-------------------------------------------------------------------

Solution pour exo13:

solutionexo13.ino
//-------------------------------------------------------------------
/*!
 * \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 broche. 
 * La liste des vecteur 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();
}
//Début solution
void setupINT0(){
  pinMode(LEDPIN, OUTPUT);
  digitalWrite(LEDPIN,HIGH);
  pinMode(BUTTONPIN, INPUT_PULLUP);
  cli();           // disable all interrupts
  EICRA= (EICRA&0xFC) |2; //ICS0 = 10 pour front descendant
  EIMSK= EIMSK|1; //enable INT0
  sei();             // enable all interrupts
}
//-------------------------------------------------------------------
/* PROBLEME IL Y A LES REBONDS SUR LE POUSSOIR.... anti rebond par logiciel  
 * en inhibant les interruptions après la première pendant un certain temps
  */
ISR(INT0_vect) {
  unsigned int minTempsEntreIT0=300;
  static unsigned long timerIT0 = millis();
  static unsigned char counter=0;
  unsigned long timeActuel=millis();
  if ( timeActuel - timerIT0 >= minTempsEntreIT0) {
    timerIT0=timeActuel;
    if (counter==0)  
      digitalWrite(LEDPIN,LOW); //allume
    else
      digitalWrite(LEDPIN,HIGH); //eteind
    counter = (counter+1)%2;
    Serial.println("it");
    }
}
////autre exo à envisager: désactivation dans l'it puis réactivation dans loop via timer partagé
//-------------------------------------------------------------------
//temporisation avec interruption timer -> sera vu au tp suivant sur afficheur 7 segments
//-------------------------------------------------------------------
 
//Fin solution

</file> Compléter ce fichier exercice par exercice en utilisant les commentaires comme consignes.

En fin de séance, penser à récupérer le texte de votre programme sur votre ordinateur et à mémoriser l'URL pour pouvoir retrouver votre projet.

Documentation sur l'outils de documentation 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++

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

cesitd1.txt · Dernière modification: 2021/12/03 10:49 de bvandepo

Outils de la page