petits exemples LCD, horloge, communication, motor, capteur IUT soissons

International Français Le bar
1

A cause du confinement du covid X,
J’ai demandé à mes étudiants d’IUT première année de se familiariser avec l’écriture du forum et de s’entre aider entre eux, pour faire quelques programmes

Exercice 1
Sur la première ligne du LCD, Ecrire votre nom avec à la fin le caractère µ(micro).
Sur la deuxième ligne, les secondes qui s’incrémentent avec une routine d’interruption
De Faire, une simulation avec ISIS de leur programme en mode pause, faire une copie d’écran avec le déroulement du programme et de mettre sur le forum cette copie d’écran
De plus de mettre leurs programmes avec des commentaires pour qu’il soit vu en tant que programme.

Meme si c’est copié ce n’est pas grave……mais mettre une fausse valeur de l’ecriture µ (micro)

Voici l’exemple de ce qui est demandé

Exercice 2
Avec d’un seul terminal dans ISIS, je vous propose seulement, que vous écriviez un programme ou l’affichage des secondes déroulantes, toutes les seconds sur le terminal
Et si vous écrivez votre nom dans le terminal , celui s’affiche sur l’écran LCD.
Faire une capture d’écran et poster le, ainsi que votre code sur le lien suivant

Pour que le virtual terminal envoie des données, pendant la simulation click droit sur l'ecran du terminal, il faut activer « echo type characters »
Comme sur la photo suivante

Exercice 3

Faire un programme pour afficher l’heure, les minutes, les secondes sur l’afficheur LCD sur la deuxième ligne, avec la routine d’interruption.
Donc au bout de 60secondes, les minutes s’incrémentent, au bout de 60 minutes les heures s’incrémente…etc…bref, une horloge numérique.
Initialisé les variables à 23heures, 59 minutes et 30 secondes et faire une capture d’écran au bout de 40 secondes pour vérifier que votre programme est correcte, comme on peut l’observer sur la figure suivante

Il y a aura toujours votre nom sur l’afficheur LCD pour prouver que c’est bien vous.
Mettre votre programme en ligne pour que je puisse noter et vérifier votre code.

exercice 4

Pour vérifier que vous avez compris l’utilisation des instructions analogRead et analogWrite ainsi que celle des instruments d’ISIS. Je vous propose d’utiliser l’Arduino nano pour faire du traitement de signal et faire un voltmètre DC mais aussi AC de l’entrée avec 5V amplitude max. Aucun composant extérieur sera utile, mais avec juste avec un pont diviseur de tension, il sera possible de mesurer jusque 400V.

Vous allez devoir réaliser un petit programme qui mesure une tension triangulaire ou sinusoidale (offset de 2.5V, bouton unipolaire du GBF, amplitude 4.9v ou de 3V, fréquence 50Hz).
Ce signal lu par l’Arduino avec une fréquence d’échantillonnage de 1ms grâce à la routine d’interruption, sera ressorti sur la PWM broche 3 avec une amplitude divisé par 2, ainsi que sa valeur moynne. Le signal de la PWM à 32khz sera filtré par une résistance et un condensateur qui a une fréquence de coupure de 500Hz pour avoir une tension analogique.
Sur l’oscilloscope, la tension du GBF et la tension de sortie du filtre de la PWM seront vérifiées.
Le programme calculera la tension moyenne DC du signal d’entrée, pour l’afficher sur l’écran LCD. De plus, votre programme mesurera l’amplitude. (Il y a de nombreuses méthodes pour les mesures, je vous laisse utiliser celle que vous voulez)
Votre nom sera toujours sur la première ligne sur l’afficheur LCD.

Vous pouvez vous inspirer du post « filtre numérique » qui est sur le lien suivant
https://forum.arduino.cc/index.php?topic=668939.0

D’ailleurs, dans ISIS garder que l’Arduino, le LCD faire le filtre RC….retirer tous les composants qui sont inutiles.
Vérifier que votre programme fonctionne bien de 5Hz à 250Hz.
Puis, comme d’habitude, vous mettrez votre code, 2 captures d’écrans pour prouver que votre programme fonctionne bien avec une amplitude de 4.9Vpuis 3V.
Expliquer quelle est la précision de votre voltmètre et ces limites pour faire une synthèse.

Voici une capture d’écran, de ce qu’il faut faire, sans la partie fréquencemètre


Votre programme doit aussi bien fonctionné pour tous types de signaux

Exercice 5
Dans la continuité de l’exercice 4, Le processeur peut être utilisé comme compteur, donc faire un fréquencemètre.

L’Arduino a une instruction pour la routine extérieure et sur la nano, il n’y a que les broches 2 et 3 qui sont concernés, mais la broche 3 est déjà utilisée pour la PWM.
attachInterrupt (digitalPinToInterrupt(pin), ISR, mode)
Pour mesurer le comptage du temps entre 2 fronts, il y a 2 instructions possible time = millis() ou micros() qui utilise le timer0 de 8 bits de l’Atmega 328. Voir le lien suivant.
https://www.locoduino.org/spip.php?article84
Il faudra utiliser un AOP pour triguerisé le signal pour la routine d’interruption extérieure.
Mais avec une routine d’interruption de 1ms du timer1, il est possible de l’utiliser sans utiliser les 2 instructions millis ou micro.

Par contre, la routine d’interruption extérieure devra être la plus courte possible car il n’y aura pas de priority entre la routine d’interruption extérieure et la routine timer1.

Vérifier que votre fréquencemètre fonctionne bien de 5Hz à 500Hz.
Puis, comme d’habitude, vous mettrez votre code, 1 capture d’écrans pour prouver que votre programme fonctionne bien avec la fréquence du GBF et celle affichée sur l’écran LCD, ainsi que votre nom.

Exercice 6

Les afficheurs LCD sont relativement petits, donc souvent il faut gérer différents menus par l’intermédiaire de bouton poussoir.
Etant donné que les routines d’interruptions étant relativement courtes en temps d’instruction ainsi que la boucle loop, cela permet dans la loop de scruter des entrées pour savoir si un bouton poussoir est activé ou pas. Sachant que l’homme est lent car il va appuyer au moins pendant 0.15s.
On utilisera la résistance de pull up interne à l’Arduino
voir LOCODUINO - Entrées numériques et résistance pull-up

  • Donc, 1 bouton poussoir permettra d’incrémenter un menu déroulant permettra d’afficher la tension moyenne, l’amplitude, la fréquence, la valeur efficace TRMS (true root mean square)
  • Un autre bouton poussoir permettra de figer la valeur des mesures en mettant en Haut à gauche de l’écran LCD les lettres « Me» comme mémoire.

(Première ligne votre nom, deuxième ligne ce que vous mesurez, troisième ligne la valeur et l’unité)
Comme d’habitude mettre une seule capture d’écran et votre programme.
Voici un exemple de la gestion des menus

Lorsque la mémoire est activée, la sortie analogwrite est aussi arrété comme on peut l’observer sur l’oscciloscope

2 
// include the library code:
#include <LiquidCrystal.h>
//#include <SoftwareSerial.h>
#include <TimerOne.h>
//#include <math.h>
LiquidCrystal lcd(9, 8, 4, 5, 6, 7);   // LiquidCrystal lcd(rs, en, d4, d5, d6, d7);
// Configuration des variables
long temps;

void setup() {
lcd.begin(16, 2);                   //modifier pour un afficheur 16x2
// Serial1.begin(9600);
  Timer1.initialize(1000000);           // timer 1 à 1000000 -> periode de 1s
  Timer1.attachInterrupt(Routinetimer1);   // attaches le sous programme  Routinetimer1 as a timer overflow interrupt 
lcd.setCursor(0,0);// configuration de l'écran lcd
lcd.print("   Seghier.s ");// ecriture de mon nom.premiere lettre du prenom
lcd.print(char(870)); // faux symbole micro comme demandé


}//fin setup
// Interruptions  tous les 1s fait par le timer1***********************************
void Routinetimer1()  {
lcd.setCursor(0,1);//configuration de la deuxieme ligne de l'écran
lcd.print("        ");// espacement pour faire beau
lcd.print(temps);// ecriture de la variable temps qui s'incremente a chaque secondes
temps++;// la variable temps s'incrémente toutes les secondes

}//fin routineinterruption
///////////////////////////////////////////// Boucle correspondant à la fonction main 
void loop() {  


} // fin loop

501×620 63.1 KB

3

Exercice 1

#include <LiquidCrystal.h>
#include <TimerOne.h>
LiquidCrystal lcd(9, 8, 4, 5, 6, 7);   // LiquidCrystal lcd(rs, en, d4, d5, d6, d7);
// Configuration des variables
long temps=0;
// the setup function runs once when you press reset or power the board
void setup() {    
lcd.begin(16, 2);                   //modifier pour un afficheur 20x4
// Serial1.begin(9600); 

  Timer1.initialize(1000000);           // 1 000 000 = 1sec de période 
  Timer1.attachInterrupt(Routinetimer1);   // attaches le sous programme  

  TCCR2B = (TCCR2B & 0b11111000) | 0x01;         //pin 3  32khz       
lcd.setCursor(4,0); //x=4 y=0
lcd.print("bucci.m ");
lcd.print((char)870);//faux caractère micro             
}//fin setup

// Interruptions  tous les 1s fait par le timer1
void Routinetimer1()  {
temps++;        //incrémentation des secondes
lcd.setCursor(8,1);//x=8 y=1
lcd.print(temps);//afficher les secondes
} 

void loop() {  
} // fin loop

4

c'est bien, il y en a qui sont en avance sur la date de mettre le travail d'une journée

vu le choix de la routine d'interruption à 1s,
moi, j'aurai mis l'affichage des secondes dans la routine

l'affichage du nom dans le set up

effacer l'ecran ne sert à rien
donc, il n'y aurai plus rien dans la boucle loop, ce qui permet de la remplir dans le futur avec autre chose.

5 
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27,16, 2);
void setup()
{
  lcd.init(); //intitialisation de l'ecran LCD
  lcd.begin(16,2);  //afficheur 16x2
  lcd.backlight();  //retro éclairage
  lcd.noCursor(); //suppression du curseur
  lcd.setCursor(0 , 0); //curseur initialisation à la colone 0 de la premiere ligne
  lcd.print("Mathieu.S"); //affiche Mathieu.S
  lcd.print((char)870); //affiche le caractère micro
  }
  
void loop()
{
  int counter;
  lcd.setCursor(0 , 1); //curseur initialisation à la colone 0 de la deuxieme ligne
  for(counter=0;counter<=10;counter++)  //boucle pour
  {
    lcd.print("                ");  //clear de la deuxieme ligne
    lcd.setCursor(0 , 1); //curseur initialisation à la colone 0 de la deuxieme ligne
    lcd.print(counter); //afficher la valeur de la variable counter
    delay(1000);
    }
}
6

Exercice n°1

#include <LiquidCrystal.h>
#include <TimerOne.h>
LiquidCrystal lcd(9, 8, 4, 5, 6, 7);   

long temps=0;
// the setup function runs once when you press reset or power the board
void setup() {
// put your setup code here, to run once:
lcd.begin(16, 2);                   
// Serial1.begin(9600);

Timer1.initialize(1000000);          
Timer1.attachInterrupt(Routinetimer1);  

TCCR2B = (TCCR2B & 0b11111000) | 0x01;       
lcd.setCursor(4,0); 
lcd.print(" pioche.c ");
lcd.print((char)228);         

}//fin setup
void Routinetimer1() { 
temps++;
    }

void loop() {
// put your main code here, to run repeatedly:
lcd.setCursor(8,1);
lcd.print(temps);
}

1448×900 173 KB

7

il faut utiliser la routine d'interruption et faire une capture d'ecran de la simulation
mettre l'image sur un hebergeur d'image de votre capture d'ecran (j'ai explique dans le mail)

pour mathieu et cedric il faut utiliser la routine d'interuption pas de delays
mathieu, tu utilise un LCD avec I2C et ce n'est pas possible d'affciher daans la routine interruption, tu es obligé, de le faire dans la loop

inspirer vous de bucci et seguier, ils ont bon
mais c'est deja une belle premire etape

il est possible de mettre un jpg en fichier attaché

8 
#include <LiquidCrystal.h>
#include <TimerOne.h>
LiquidCrystal lcd(9, 8, 4, 5, 6, 7); 
//variables
long time=0;


void setup() {   
lcd.begin(16, 2);              //modification affichage 20x4
// Serial1.begin(9600);

  Timer1.initialize(1000000);           //période 1s
  Timer1.attachInterrupt(Routinetimer1);   //sous prog      
}

//Timer 1 interruption ttes les s
void Routinetimer1()  {
time++;        //seconde +1
}
void loop() { 
lcd.setCursor(0,0); //x=4 y=0
lcd.print("Pruvot.A ");//afficahge Nom.Lettre
lcd.print((char)NOP);//caractère micro
lcd.setCursor(8,1);//x=8 y=1
lcd.print(time);//affichage des secondes
delay(100);//délais 0.1s
lcd.clear();//refresh lcd
}

9

Arghhhhhh... même si on est dans le bar essayez de respecter les balises pour mettre le code

:grin:

10 
#include <LiquidCrystal.h>
#include <TimerOne.h>
LiquidCrystal lcd(9, 8, 4, 5, 6, 7);
//variables
long time=0;


void setup() {
lcd.begin(16, 2);              //modification affichage 20x4
// Serial1.begin(9600);

Timer1.initialize(1000000);           //période 1s
Timer1.attachInterrupt(Routinetimer1);   //sous prog
}

//Timer 1 interruption ttes les s
void Routinetimer1()  {
time++;        //seconde +1
}
void loop() {
lcd.setCursor(0,0); //x=4 y=0
lcd.print("Gut.A ");//afficahge Nom.Lettre
lcd.print((char)0b11100100);//caractère micro
lcd.setCursor(8,1);//x=8 y=1
lcd.print(time);//affichage des secondes
delay(100);//délais 0.1s
lcd.clear();//refresh lcd
}

Capture_decran_8.png

11

[Info]
Bonjour, voici mon horloge comptant les secondes et qui affiche également mon nom.prénom µ.

Voila le programme :

#include <LiquidCrystal.h>
#include <TimerOne.h>

const byte rs = 12, en = 11, d4 = 5, d5 = 4, d6 = 3, d7 = 2;
LiquidCrystal lcd(rs, en, d4, d5, d6, d7);    //précise les broches à la librairie <LiquidCrystal.h>

unsigned long Time= 0;

unsigned long counter(){
  Time++; // s'incrémente toutes lesd secondes
  lcd.setCursor(0,1);
  lcd.print(Time);
}

void setup() {
  lcd.begin(16,2);  //démarre la communication avec un lcd de 16x2 
  lcd.setCursor(0,0);
  char mes[16];     //message de la première ligne
  sprintf(mes,"Wysocki.B %c",228); // remplace les char du tableau "mes" par la chaîne, 228 est le symbole µ le %c dans la chaîne de char sert à indiquer que la variable est un char
 
  lcd.print(mes);
  
  Timer1.initialize(1000000);       //initialize le timer à 1s (une interruption par seconde)
  Timer1.attachInterrupt(counter);  //attache l'interruption à la fonction "counter"
}

void loop() {}

Et voila la photo de la simulation :

12

Bonjour, voici mon horloge :

#include <LiquidCrystal.h>
#include <TimerOne.h>
LiquidCrystal lcd(9, 8, 4, 5, 6, 7);   // LiquidCrystal lcd(rs, en, d4, d5, d6, d7);
// Configuration des variables
long temps=0;
// the setup function runs once when you press reset or power the board
void setup() {   
lcd.begin(16, 2);                   //modifier pour un afficheur 20x4
// Serial1.begin(9600);

  Timer1.initialize(1000000);           // 1 000 000 = 1sec de période
  Timer1.attachInterrupt(Routinetimer1);   // attaches le sous programme 

  TCCR2B = (TCCR2B & 0b11111000) | 0x01;         //pin 3  32khz                   
}//fin setup

// Interruptions  tous les 1s fait par le timer1
void Routinetimer1()  {
temps++;        //incrémentation des secondes
}

void loop() { 
lcd.setCursor(4,0); //x=4 y=0
lcd.print("deconinck ");
lcd.print((char)870);//caractère micro
lcd.setCursor(8,1);//x=8 y=1
lcd.print(temps);//afficher les secondes
delay(100);//actualisation
lcd.clear();//clear du lcd
} // fin loop

horloge deconinck.PNG

13

Bonjour à tous, voici l'exercice 1, 2 et 3 de Youssef ALI :

Exercice 1

Le code :

#include <LiquidCrystal.h>
#include <TimerOne.h>
LiquidCrystal lcd(9, 8, 4, 5, 6, 7); //configuration du brochage de l'écran LCD

long time = 0;


void setup() {
  lcd.begin(16, 2);              //affichage 16x2

  Timer1.initialize(1000000);           //timer 1 à 1000000 -> periode de 1s
  Timer1.attachInterrupt(Routinetimer1);   //attache sous programme Routinetimer1 as a timer overflow interrupt

  lcd.setCursor(5, 0); //x=5 y=0
  lcd.print("ALI.y");//ecriture nom.premiere lettre

  lcd.setCursor(15, 0);
  lcd.print((char)0b11100100); //caractère micro
} //fin setup

//Timer 1 interruption ttes les s
void Routinetimer1()  {
  time++;        //seconde +1
}

void loop() {
  //lcd.print(char(870)); //caractère micro
  lcd.setCursor(9, 1); //x=9 y=1
  lcd.print(time);//affichage des secondes
  delay(100);//délais 0.1s
  //lcd.clear();//refresh lcd
}

Voici le résultat :

Nous pouvons constater que le temps de simulation est similaire à celui affiché par l'écran LCD. L'interruption est donc correctement faite.

PS :
-Afin d'héberger l'image j'ai utilisé l'hébergeur suivant : https://www.zupimages.net/
Celui ci est très simple d'utilisation, il suffit d'uploader son image et copier/collé le "Code BBCode (pour forum)"

-Afin de copier mon code en version forum j'ai sélectionné tout mon code sur l'IDE, puis on clique sur "Edition", ensuite "Copier pour le forum". On peut aussi utiliser le raccourci "Ctrl + maj + C"

Exercice 2

-Afin de réaliser cette exercice, nous sélectionnons sur isis le "Virtual Terminal" présent dans la catégorie "Instruments" :

-Il faut ensuite le connecter au Tx (transmission) et Rx (réception) de notre carte Arduino mais attention : il faut veiller à les croiser. Nous pouvons prendre l'exemple d'une bouche (transmetteur) qui parle à une oreille (récepteur) :

Pour donner suite au cahier des charges donnés, nous pouvons le décomposer en plusieurs tâches.

-J'ai commencé par simplement émettre un message. Voici le code Arduino :

#include <LiquidCrystal.h>
#include <TimerOne.h>
LiquidCrystal lcd(9, 8, 4, 5, 6, 7);  //configuration du brochage de l'écran LCD

long time = 0;

void setup() {
  lcd.begin(16, 2);              //affichage 16x2
  Serial.begin(9600);
  
  Timer1.initialize(1000000);           //timer 1 à 1000000 -> periode de 1s
  Timer1.attachInterrupt(Routinetimer1);   //attache sous programme Routinetimer1 as a timer overflow interrupt

  lcd.setCursor(0,0);
  lcd.print("HELLO WORLD");
  Serial.print("HELLO WORLD\n"); //affichage sur l'ecran d'un message
}

//Timer 1 interruption ttes les s
void Routinetimer1()  {
  time++;        //seconde +1
}

void loop() {
}

-Maintenant que ça fonctionne correctement nous pouvons passer à la tâche suivante qui est d'afficher les secondes :

Pour cela, il suffit de taper le code suivant dans l'interruption :

//Timer 1 interruption ttes les s
void Routinetimer1()  {
  time++;        //seconde +1
  Serial.println(time);
}

Voici le résultat :

-Enfin, nous passons à la réception d'un message pour l'afficher sur l'écran :

void loop() {
  while (Serial.available()) { // tant que des caractères sont en attente d'être lus
    char c = Serial.read(); // on lit le charactère
    lcd.setCursor(colonne,ligne); //on précise où l'écrire
    lcd.print(c); // on l'écrit sur l'écran LCD
    colonne++;  //on décale de colonne
    if(colonne == 15) colonne = 0;  //Si on dépasse le nombre de caractères, on revient au premier
    if(ligne == 1) ligne = 0; //pareil pour les lignes
    delay(10); // petit temps de pause
  }  
}

Voici le résultat :

Exercice 3 :

Voici le programme permettant de réaliser l'exercice 3, comment afficher l'heure sur un écran LCD et une carte Arduino :

#include <LiquidCrystal.h>
#include <TimerOne.h>
LiquidCrystal lcd(9, 8, 4, 5, 6, 7);  //configuration du brochage de l'écran LCD



int heure = 23;   //déclaration heure
int minute = 59;  //déclaration minute
int seconde = 30; //déclaration seconde

void setup() {
  lcd.begin(16, 2);              //affichage 16x2
    
  Timer1.initialize(1000000);           //timer 1 à 1000000 -> periode de 1s
  Timer1.attachInterrupt(Routinetimer1);   //attache sous programme Routinetimer1 as a timer overflow interrupt 
}

//Timer 1 interruption ttes les s
void Routinetimer1()  {
  seconde++;        //seconde +1
  Serial.println(seconde);
}

void horloge(){             //Fonction horloge
  if(seconde >= 60){  //lorsqu'on dépasse 60 secondes, la variable est mise à 0 puis minute est incrémenté
    seconde = 00;
    minute++;
    if(minute >= 60){ //lorsqu'on dépasse 60 minutes, la variable est mise à 0 puis heure est incrémenté
      minute = 00;
      heure++;
      if(heure >=24){ //lorsqu'on arrive à minuit, on passe heure à 0 puis on efface l'écran
        heure = 00;
        lcd.clear();
      }
    }
  }
}

void affichage_horloge(){
  lcd.setCursor(1,1);     //affichage des heures
  lcd.print(heure);
  lcd.setCursor(3,1);
  lcd.print("h");

  lcd.setCursor(5,1);     //affichage des minutes
  lcd.print(minute);
  lcd.setCursor(7,1);
  lcd.print("m");

  lcd.setCursor(9,1);     //affichage des secondes
  lcd.print(seconde);
  lcd.setCursor(11,1);
  lcd.print("s");
}

void loop() {
  lcd.setCursor(0,0);     //écriture NOM.premiere lettre prénom
  lcd.print("ALI.y EX3");
  
  horloge();    //lancement de la fonction horloge

  affichage_horloge();  //affichage de l'horloge sur l'écran LCD   
}

Voici le résultat :

Au départ :

Au bout de 40 secondes :

14

Bonjour , voici l'exo 1 : Affichage sur LCD :o :
Le code :

#include <LiquidCrystal.h>
#include <TimerOne.h>
LiquidCrystal lcd(9, 8, 4, 5, 6, 7);   // LiquidCrystal lcd(rs, en, d4, d5, d6, d7);
// Configuration des variables
long temps;

void setup() {  
lcd.begin(16, 2);              //modifier pour un afficheur 16x2
 Timer1.initialize(1000000);           //ici nous avons la période qui vaut 1s
 Timer1.attachInterrupt(Routinetimer1);   //Sous programme RoutineTimer1 | Timer 1 = interruption toutes les sec 
}


void Routinetimer1()  {
temps++;        // on ajoute/incremente une seconde
}
void loop() {
lcd.setCursor(0,0); //Initialisation de l'écran LCD
lcd.print("PREVOST.L ");//Affichage de mon Nom
lcd.print((char)228);//affichage du caractère micro(228) 
lcd.setCursor(8,1);//nous mettons : x=10 y=1
lcd.print(temps);//affichage des secondes
delay(100);//délais de 0.1s
}

Resultat sur ISIS : Nous voyons bien que le temps de simulation est identique au temps indiqué sur le LCD

J'ai utilisé le même site que ali_y pour héberger mon image (https://www.zupimages.net) :

  • Parcourir pour mettre son image
  • Valider
  • Copier "Code BBCode (pour forum) "
  • Coller ici 8)
15

Exercice 1:

#include <LiquidCrystal.h>
#include <TimerOne.h>
LiquidCrystal lcd(9, 8, 4, 5, 6, 7);
long temps=0;

void setup() {
  lcd.begin(16,2);                         //afficheur 20x4
  //Serial1.begin(9600);

  
  Timer1.initialize(1000000);              // une période de 1sec
  Timer1.attachInterrupt(Routinetimer1);   // attaches le sous programme Routinetimer1
  
}

void Routinetimer1() {    //Sous programme pour le comptage des secondes
  temps++;                //incrémentation d
}

void loop() {
  lcd.setCursor(3,0);       //le curseur est placé sur la colonne 3 de la première ligne
  lcd.print("Padros.C ");    //affiche Padros.C
  lcd.print((char)228);     //affiche le caractère micro
  lcd.setCursor(8,1);       //le curseur est placé sur la colonne 8 de la deuxième ligne
  lcd.print(temps);         //permet d'afficher les secondes
  delay(100);               //délais servant à actualiser le lcd
  lcd.clear();              //clear le lcd
}

Voici l'image de la simulation sous Isis

Exercice 2:

#include <LiquidCrystal.h>
#include <TimerOne.h>
#include <SoftwareSerial.h>

LiquidCrystal lcd(9, 8, 4, 5, 6, 7);
long temps=0;
char lecture;

void setup() {
  lcd.begin(16,2);                         //afficheur 20x4
  Serial.begin(9600);

  
  Timer1.initialize(1000000);              // une période de 1sec
  Timer1.attachInterrupt(Routinetimer1);   // attaches le sous programme Routinetimer1
  
}

void Routinetimer1() {    //Sous programme pour le comptage des secondes
  temps++;                //incrémentation d
}

void loop() {
  Serial.print(temps);   //affiche le contenu de "temps"
  Serial.println(";");   //affiche ";"
  delay(1000);           //délai de 1sec
  
  while(Serial.available()>0) 
  {
    lecture=Serial.read();
    lcd.print((char)lecture);
    }
  /*
  lcd.setCursor(3,0);       //le curseur est placé sur la colonne 3 de la première ligne
  lcd.print("Padros.C ");    //affiche Padros.C
  lcd.print((char)228);     //affiche le caractère micro
  lcd.setCursor(8,1);       //le curseur est placé sur la colonne 8 de la deuxième ligne
  lcd.print(temps);         //permet d'afficher les secondes
  delay(100);               //délais servant à actualiser le lcd
  */
}

Voici l'image de la simulation sous Isis

Exercice 3

#include <LiquidCrystal.h>
#include <TimerOne.h>
LiquidCrystal lcd(9, 8, 4, 5, 6, 7);  //configuration du brochage de l'écran LCD



int heure = 23;   //déclaration heure
int minute = 59;  //déclaration minute
int seconde = 30; //déclaration seconde

void setup() {
  lcd.begin(16, 2);                        //affichage 20x4
  Serial.begin(9600);
  Timer1.initialize(1000000);              //une période de 1sec
  Timer1.attachInterrupt(Routinetimer1);   //attache sous programme Routinetimer1
}

void Routinetimer1()  {   //Sous programme pour le comptage des secondes
  seconde++;              //incrémentation de seconde de 1
}

void horloge(){             //Fonction pour l'horloge
  if(seconde >= 60){        //si "seconde">= à 60, alors "minute" est incrémenté de 1
    seconde = 00;           //on met "seconde" à 0
    minute++;               //incrémentation de "minute" de 1
    if(minute >= 60){       //si "minute" >= à 60, alors "heure" est incrémeté de 1
      minute = 00;          //on met "minute" à 0
      heure++;              //incrémentation de "heure" de 1
      if(heure >=24){       //si "heure">= à 24, alors on met "heure" à 0 et on efface l'écran
        heure = 00;         //on met "heure" à 0
        lcd.clear();        //on clear le lcd
      }
    }
  }
}

void affichage_horloge(){
  lcd.setCursor(1,1);     //affichage des heures
  lcd.print(heure);
  lcd.setCursor(3,1);
  lcd.print("h");

  lcd.setCursor(5,1);     //affichage des minutes
  lcd.print(minute);
  lcd.setCursor(7,1);
  lcd.print("m");

  lcd.setCursor(9,1);     //affichage des secondes
  lcd.print(seconde);
  lcd.setCursor(11,1);
  lcd.print("s");
}

void loop() {
  Serial.print(seconde);   //affiche le contenu de "temps"
  Serial.println(";");   //affiche ";"
  delay(1000);           //délai de 1sec
  
  lcd.setCursor(3,0);     
  lcd.print("PADROS.C");  //affiche PADROS.C sur le LCD
  
  horloge();              //lancement de la fonction horloge
  affichage_horloge();    //affichage de l'horloge sur l'écran LCD   
}

Voici l'image de la simulation sous Isis

Exercice 4 et 5

#include <LiquidCrystal.h>
#include <SoftwareSerial.h>
#include <TimerOne.h>


#define PWM3   3      //   timer2   
#define LED13    13     
LiquidCrystal lcd(9, 8, 4, 5, 6, 7);             //configuration du brochage de l'écran LCD

// Configuration des variables
unsigned int temps1=1, Time=0, TO=0;

float entreeMax,DC,DC1,f,m;

unsigned    int    temps=0;
            float  entree=0;                   
            float  sortie=0;
         
                   

void setup() {
  pinMode(LED13, OUTPUT);                        //LED13 et PWM3 sorties
  pinMode(PWM3,OUTPUT);

  Timer1.initialize(1000);                       // période de 0.001sec
  Timer1.attachInterrupt(callback);              // attache sous programme callback()
  lcd.begin(20, 4);                              // initialise un afficheur 20x4
  Serial.begin(9600);
  lcd.setCursor(0,0);                            //placement du curseur
  lcd.print("Exo 4 & 5 DC/AC");
  TCCR2B = (TCCR2B & 0b11111000) | 0x01;         //pin 3  32khz    http://playground.arduino.cc/Main/TimerPWMCheatsheet
  attachInterrupt(0, interrup2, FALLING);        //interruption à chaque front descendant
}

void interrup2(){                                //routine d'interruption michel 2
  Time=temps1; 
  temps1=0;
}

// Interruption toutes les 1ms fait par le timer1
void callback()  {

  temps1++;                                     //incrémentation de temps1

  digitalWrite(LED13,HIGH);                     //permet de mesurer grâce à l'oscillo, le temps du calcul du filtre et le temps de la routine d'interruption
  entree=analogRead(A0);                        //convertisseur 10 bits sous 5V
 


  sortie=entree/4  ;                            //mise à l'echelle 10 bits en entrée et 8 bits en sortie
  sortie=sortie/2;
  if (sortie>254)  {sortie=254;}
    if (sortie<0) sortie=0;
      analogWrite(PWM3,sortie);         


  digitalWrite(LED13,LOW);
    temps++;
    if (temps>=200) {
      entree=0;
      temps=0;
      DC1=DC/200; //
      DC=0;
      entreeMax=0;
    }
    if(entree>entreeMax) {entreeMax=entree;}

   DC=entree+DC;

 


}//fin de callback()



void loop() { 
 
  lcd.setCursor(0,1);
  lcd.print("DC ");

  lcd.print((DC1*5)/(1024),2);
  lcd.print("V    ");
 
  lcd.setCursor(0,2);
  lcd.print("AC "); 
  lcd.print((entreeMax*5)/(1024),2);
  lcd.print("V    ");

  lcd.setCursor(0,3);
  lcd.print("f "); 
  f=1000/Time;    //calcul de la frequence
  lcd.print(f);
  lcd.print("Hz    ");
 
} // fin loop

16 
#include <LiquidCrystal.h>
#include <TimerOne.h>
LiquidCrystal lcd(9, 8, 4, 5, 6, 7);   // LiquidCrystal lcd(rs, en, d4, d5, d6, d7);
// Configuration des variables
long temps=0;

void setup() {  
lcd.begin(16, 2);                   // " Taille "afficheur
// Serial1.begin(9600);

Timer1.initialize(1000000);           // correspond à la période (1s)
Timer1.attachInterrupt(Routinetimer1);   //sous programme

TCCR2B = (TCCR2B & 0b11111000) | 0x01;         //pin 3                    
}//fin setup

// Interruptions  tous les 1s fait par le timer1
void Routinetimer1()  {
temps++;        //incrémentation du temps (seconde)
}

void loop() { //début loop
lcd.setCursor(4,0); //x=4 y=0
lcd.print("barbieux.c ");
lcd.print((char)228);//Caractère micro
lcd.setCursor(8,1);//Coordonnées x=8 y=1
lcd.print(temps);//Afficher les secondes
delay(100);//Actualisation
lcd.clear();//"Nettoyage de l'écran du lcd
} // fin loop

17

Exercice n°2 :
Alexandre

#include <LiquidCrystal.h>
#include <TimerOne.h>
#include <SoftwareSerial.h>
//variables
byte secondes=0;
char lecture;
LiquidCrystal lcd(9, 8, 4, 5, 6, 7);


void setup() {
lcd.begin(16, 2);              //modification affichage 20x4
Serial.begin(9600);          //adresse du terminal

Timer1.initialize(1000000);           //période 1s
Timer1.attachInterrupt(Routinetimer1);   //sous prog
}

//Timer 1 interruption ttes les s
void Routinetimer1() 
  {
      secondes++;        //seconde +1
  }
void loop() 
  { 

      Serial.print(secondes);     //affiche les secondes dans le terminal
      Serial.println(";");            //affiche ; dans le terminal
      delay(1000);                   //delais
    if (Serial.available() > 0) {         //si quelque chose s'ecrit dans le terminal :
      lecture=Serial.read();              //lit l'ecriture du terminal et le stoque dans lecture
      lcd.print((char)lecture);            //affiche lecture dans lcd
    }

}

18

Exercice 1 :

// include the library code:
#include <LiquidCrystal.h>
//#include <SoftwareSerial.h>
#include <TimerOne.h>

LiquidCrystal lcd(9, 8, 4, 5, 6, 7);   // LiquidCrystal lcd(rs, en, d4, d5, d6, d7);
// Configuration des variables

unsigned    int   timer=0; //Timer

// the setup function runs once when you press reset or power the board
void setup() { 

  lcd.begin(16, 2);                   //modifier pour un afficheur 16x2
Timer1.initialize(100000);           // initialize timer1, and set a 0,1 second period =>  100 000  pour 0.01s  10 000
Timer1.attachInterrupt(Routinetimer1);   // attaches le sous programme  Routinetimer1 as a timer overflow interrupt

// Serial1.begin(9600);
}//fin setup

// Interruptions  tous les 1s fait par le timer1***********************************
void Routinetimer1()  {
timer++;
if (timer>1) {  
  if ( digitalRead(11)== 1 ) {digitalWrite(11,LOW);}  else {digitalWrite(11,HIGH);}
   timer=0;
                }
}//fin routineinterruption


///////////////////////////////////////////// Boucle correspondant à la fonction main 
void loop() {  
lcd.setCursor(0,0);
lcd.print("Jarray.A ");       //affichage de la NOM et PRENOM sur LCD
lcd.print((char)228);            //affichage charactere micro
lcd.setCursor(0,1);             //retourner à la ligne
lcd.print(timer);              //affichage compteur 
   
} // fin loop

![](http://<a target=)

585×655 12.2 KB
">

Exercice 2 :

#include <LiquidCrystal.h>
#include <TimerOne.h>
#include <SoftwareSerial.h>
//variables
byte scnds=0;
char Read;
LiquidCrystal lcd(9, 8, 4, 5, 6, 7);


void setup() {
lcd.begin(16, 2);              //modification affichage 20x4
Serial.begin(9600);          //adresse du terminal

Timer1.initialize(1000000);           //période 1s
Timer1.attachInterrupt(Routinetimer1);   //sous prog
}

//Timer 1 interruption ttes les s
void Routinetimer1()
  {
      scnds=scnds+1;        //seconde +1
  }
void loop()
  {

      Serial.print(scnds);     //affiche les secondes dans le terminal
      Serial.println(";");            //affiche ; dans le terminal
      delay(1000);                   //delais
    if (Serial.available() > 0) {         //si quelque chose s'ecrit dans le terminal :
      Read=Serial.read();              //lit l'ecriture du terminal et le stoque dans lecture
      lcd.print((char)Read);            //affiche lecture dans lcd
    }

}

Exercice 3 :

#include <LiquidCrystal.h>
#include <TimerOne.h>
LiquidCrystal lcd(9, 8, 4, 5, 6, 7);  //configuration du brochage de l'écran LCD



int heure = 23;   //déclaration heure
int minute = 59;  //déclaration minute
int seconde = 30; //déclaration seconde

void setup() {
  lcd.begin(16, 2);              //affichage 16x2
   
  Timer1.initialize(1000000);           //timer 1 à 1000000 -> periode de 1s
  Timer1.attachInterrupt(Routinetimer1);   //attache sous programme Routinetimer1 as a timer overflow interrupt
}

//Timer 1 interruption ttes les s
void Routinetimer1()  {
  seconde++;        //seconde +1
  Serial.println(seconde);
}

void horloge(){             //Fonction horloge
  if(seconde >= 60){  //lorsqu'on dépasse 60 secondes, la variable est mise à 0 puis minute est incrémenté
    seconde = 00;
    minute++;
    if(minute >= 60){ //lorsqu'on dépasse 60 minutes, la variable est mise à 0 puis heure est incrémenté
      minute = 00;
      heure++;
      if(heure >=24){ //lorsqu'on arrive à minuit, on passe heure à 0 puis on efface l'écran
        heure = 00;
        lcd.clear();
      }
    }
  }
}

void affichage_horloge(){
  lcd.setCursor(1,1);     //affichage des heures
  lcd.print(heure);
  lcd.setCursor(3,1);
  lcd.print("h");

  lcd.setCursor(5,1);     //affichage des minutes
  lcd.print(minute);
  lcd.setCursor(7,1);
  lcd.print("m");

  lcd.setCursor(9,1);     //affichage des secondes
  lcd.print(seconde);
  lcd.setCursor(11,1);
  lcd.print("s");
}

void loop() {
  lcd.setCursor(0,0);     //écriture NOM.premiere lettre prénom
  lcd.print("Jarray.A");
 
  horloge();    //lancement de la fonction horloge

  affichage_horloge();  //affichage de l'horloge sur l'écran LCD   
}

19

De Brice Lange

Exercice 1:

#include <LiquidCrystal.h>
#include <TimerOne.h>
LiquidCrystal lcd(9, 8, 4, 5, 6, 7);   // LiquidCrystal lcd(rs, en, d4, d5, d6, d7);
// Configuration des variables
long temps=0;
// the setup function runs once when you press reset or power the board
void setup() {   
lcd.begin(16, 2);                   //modifier pour un afficheur 20x4
// Serial1.begin(9600);

  Timer1.initialize(1000000);           // 1 000 000 = 1sec de période
  Timer1.attachInterrupt(Routinetimer1);   // attaches le sous programme 

  TCCR2B = (TCCR2B & 0b11111000) | 0x01;         //pin 3  32khz                   
}//fin setup

// Interruptions  tous les 1s fait par le timer1
void Routinetimer1()  {
temps++;    //incrémentation des secondes
}

void loop() { 
lcd.setCursor(4,0); //x=4 y=0
lcd.print("lange.m ");
lcd.print((char)222);//caractère micro
lcd.setCursor(8,1);//x=8 y=1
lcd.print(temps);//afficher les secondes
delay(100);//actualisation
lcd.clear();//du lcd
} // fin loop

Exercice 2:

#include <LiquidCrystal.h>
#include <TimerOne.h>
LiquidCrystal lcd(9, 8, 4, 5, 6, 7);   // LiquidCrystal lcd(rs, en, d4, d5, d6, d7);
// Configuration des variables
byte secondes=0;
int i;
 
// the setup function runs once when you press reset or power the board
void setup() {   
  lcd.begin(16, 2);                   //modifier pour un afficheur 20x4
  Serial.begin(9600);
  
  Timer1.initialize(1000000);           // 1 000 000 = 1sec de période
  Timer1.attachInterrupt(Routinetimer1);   // attaches le sous programme 

  TCCR2B = (TCCR2B & 0b11111000) | 0x01;         //pin 3  32khz                   
}//fin setup

// Interruptions  tous les 1s fait par le timer1
void Routinetimer1()  {
  secondes++;    //incrémentation des secondes
}

void loop() { 
  if(Serial.available()>0)
  {
    lcd.print((char)Serial.read());
  }
  Serial.print(secondes);
  Serial.println(";");
  delay(1000);
} // fin loop

exercice 3:

#include <LiquidCrystal.h>
#include <TimerOne.h>
LiquidCrystal lcd(9, 8, 4, 5, 6, 7);   // LiquidCrystal lcd(rs, en, d4, d5, d6, d7);
// Configuration des variables

long seconde=40;
int minute=59;
int heure=23;

// the setup function runs once when you press reset or power the board
void setup() {   
lcd.begin(16, 2);                   //modifier pour un afficheur 20x4
// Serial1.begin(9600);

  Timer1.initialize(1000000);           // 1 000 000 = 1sec de période
  Timer1.attachInterrupt(Routinetimer1);   // attaches le sous programme 

  TCCR2B = (TCCR2B & 0b11111000) | 0x01;         //pin 3  32khz                   
}//fin setup

// Interruptions  tous les 1s fait par le timer1
void Routinetimer1()  {
seconde++;//incrémentation des secondes
if(seconde==60){
  minute++;
  seconde=0;
}
if(minute==60){
  heure++;
  minute=0;
}
if(heure==24){
  heure=0;
}
}

void loop() { 
lcd.setCursor(4,0); //x=4 y=0
lcd.print("lange.m ");
lcd.print((char)228);//caractère micro
lcd.setCursor(4,1);//x=8 y=1
lcd.print(heure);//afficher les heures
lcd.setCursor(6,1);
lcd.print("h");//afficher h
lcd.setCursor(7,1);
lcd.print(minute);//afficher les minutes
lcd.setCursor(9,1);
lcd.print("m");//afficher m
lcd.setCursor(10,1);
lcd.print(seconde);//afficher les secondes
lcd.setCursor(12,1);
lcd.print("s");//afficher s
delay(100);//actualisation
lcd.clear();//du lcd
} // fin loop

20 
#include <LiquidCrystal.h>
#include <TimerOne.h>
#include <SoftwareSerial.h>

LiquidCrystal lcd(9, 8, 4, 5, 6, 7); 
//variables
byte secondes=0;
char lecture;

void setup() {   
lcd.begin(16, 2);              //modification affichage 20x4
Serial.begin(9600);

  Timer1.initialize(1000000);           //période 1s
  Timer1.attachInterrupt(Routinetimer1);   //sous prog      
}

//Timer 1 interruption ttes les s
void Routinetimer1() 
  {
      secondes++;        //secondes+1   
  }
void loop() 
  { 
      Serial.print(secondes);             //Afficher secondes
      Serial.println(";");                //Afficher ;
      delay(1000);                        //Délais 1 sec

      while(Serial.available()>0)         //Tant que Serial.variable reçoit qqch
      {
            lecture=Serial.read();        //lecture reçoit Serial.read()
            lcd.print((char)lecture);     //afficher le caractère de : lecture
      }      
/*/
lcd.print("Pruvot.A ");//afficahge Nom.Lettre
lcd.print((char)0b11100100);//caractère micro
lcd.setCursor(8,1);//x=8 y=1
lcd.print(time);//affichage des secondes
delay(100);//délais 0.1s
*/
  }