Ce tutoriel présente un exemple détaillé d'utilisation de ces fonctions.
Composants utilisés
- 1x TickShield (afficheur horloge, thermomètre buzzer et capteur de lumière).
- 1x Carte Arduino Uno
- 1x Alimentation 9V
Principe de fonctionnement
Ce shield (appelé TickShield) prêt à l'emploi fournit une plateforme multi-usages pour Arduino. Il comporte un afficheurs 4 chiffres, un buzzer, une horloge temps réel avec pile de sauvegarde, un capteur de lumière et de température, des LEDs lumineuses et des boutons de commande.
Utilisations
Ce module permet de réaliser rapidement sans soudure de nombreux projets : une alarme, un réveil, un thermomètre ou un thermostat, un capteur de lumière, un sablier ou un compte à rebours, un module de commande, un chronomètre...
Les boutons permettent par exemple de faire des choix dans des menus.
Les LEDS et l'afficheur indiquent les résultats directement sur le shield.
Ce module est idéal pour vos projets éducatifs par exemple.
Caractéristiques
Le shield comporte
- Un afficheur de 4 chiffres à 7 segments (avec un driver IC TM1636 IC pour un pilotage simplifié).
- Une horloge temps réel DS1307 incorporée, elle conserve l'heure du montage hors tension (RTC = real time clock)
- Un buzzer 5V pour alarme et émission de sons.
- Une photo résistance pour mesurer l'intensité lumineuse ambiante.
- Une thermistance pour mesurer la température de l'air.
- 4 LED pour vos témoins lumineux (bleu, vert rouge et rouge).
- 3 boutons poussoirs de commande (menus).
- Un support de pile bouton (fournie), pour conserver l'heure si l'alimentation externe est coupée.
.
.
Buzzer , led témoin, boutons de menu
Câblage
Emboiter simplement le shield sur votre carte Arduino.
Pins utilisées
Ce shield utilise 10 pins digitaux, 2 pins analogiques et le bus I2C de l'Arduino:
- D2: LED1 bleue
- D3: LED2 verte
- D4: LED3 rouge
- D5: LED4 rouge
- D6: Buzzer
- D7: TM1636 clock pin SCLK driver de l'afficheur 7 segments en I2C
- D8: TM1636 data pins DIO;
- D9: Bouton poussoir K1;
- D10: Bouton poussoir K2;
- D11: Bouton poussoir K3;
- A0: Thermistance (analogique).
- A1: Photorésistance (analogique).
- A4: DS1307 I2C data pin SDA; horloge temps réel
- A5: DS1307 I2C clock pin SCL.
Librairies
Télécharger et installer les librairies
Wire.h (pour le module horloge RTC)
MsTimer2.h (Pour le timer de l'horloge)
TM1637.h
Programmation
Exemple de code :
- Code: Tout sélectionner
//********************************************************
// Shield multiplateforme : TickShield pour Arduino
// Afficheur 4 chiffres 7 segments, LEDS, buzzer
// Commande boutons, horloge
// Capteurs : thermistance, photorésistance
// avec Driver TM1636 et carte Arduino
// demo_multiplateforme
//
// tiptopboards modifié 15 11 2014
//********************************************************
// Partiellement inspiré de : Frankie.Chu 9 April,2012
//=== Utilisation des pins par le shield multiplateforme
//D2: LED1 bleue
//D3: LED2 verte (orange)
//D4: LED3 rouge
//D5: LED4 rouge
//D6: Buzzer
//D7: TM1636 clock pin SCLK driver de l'afficheur 7 segments en I2C
//D8: TM1636 data pins DIO;
//D9: Bouton poussoir K1; KEY_DOWN
//D10: Bouton poussoir K2; KEY_UP
//D11: Bouton poussoir K3; KEY_MENU
//A0: Thermistance (analogique).
//A1: Photorésistance (analogique).
//A4: DS1307 I2C data pin SDA; horloge temps réel
//A5: DS1307 I2C clock pin SCL.
#include "Wire.h" //Pour le module RTC
#include <MsTimer2.h> //Pour le timer horloge
#include "TM1637.h" //Le driver TM1637 de l afficheur 7 segments
#define ON 1
#define OFF 0
int8_t Disp[] = {0x00,0x00,0x00,0x00}; //Tableau des 4 chiffres à afficher
unsigned char ClockPoint = 1;
// branchement I2C sur CLK -> pin 7 et DIO -->Pin 8
#define CLK 7 //D7
#define DIO 8 //D8
TM1637 tm1637(CLK,DIO); //Objet tm1637
// branchement des 4 leds témoins sur pins digitales D2-D5
const int led1 = 2; //bleu
const int led2 = 3; //vert
const int led3 = 4; //rouge
const int led4 = 5; //rouge
// branchement des 3 boutons sur pins D9-D11
#define KEY_MENU 11
#define KEY_UP 10
#define KEY_DOWN 9
//Capteurs et buzzer
#define TEMPERATURE_SENSOR A0
#define LIGHT_SENSOR A1
#define ALARM_BUZZER 6
// Horloge RTC
#define DS1307_I2C_ADDRESS 0x68
float affichage; //Valeur de la température ou photorésistance mesurée
void setup()
{
Wire.begin(); //Pour le module RTC
Serial.begin(9600); //Pour le Serial monitor
Serial.println("Module DS1307");
//Reglage initial de la date 16/08/2013 23:16:45, décommenter cette partie
/*
dayOfWeek = 7;
dayOfMonth = 16;
month = 11;
year = 14;
//Reglage de l heure
hour = 21;
minute = 58;
second = 45;
Wire.beginTransmission(DS1307_I2C_ADDRESS); // Open I2C line in write mode
Wire.write((byte)0x00); // Set the register pointer to (0x00)
Wire.write(decToBcd(second)); // Write seven bytes
Wire.write(decToBcd(minute));
Wire.write(decToBcd(hour));
Wire.write(decToBcd(dayOfWeek));
Wire.write(decToBcd(dayOfMonth));
Wire.write(decToBcd(month));
Wire.write(decToBcd(year));
Wire.endTransmission(); // End write mode
*/
// Pins des 4 LEDS en sorties
pinMode(led1, OUTPUT);
pinMode(led2, OUTPUT);
pinMode(led3, OUTPUT);
pinMode(led4, OUTPUT);
// Pins des boutons en entrées (appui force à 0)
pinMode(KEY_DOWN, INPUT_PULLUP); //bouton de droite
pinMode(KEY_UP, INPUT_PULLUP); //bouton du milieu
pinMode(KEY_MENU, INPUT_PULLUP); //bouton de gauche
//Capteurs
pinMode(TEMPERATURE_SENSOR, INPUT);
pinMode(LIGHT_SENSOR, INPUT);
//Buzzer
pinMode(ALARM_BUZZER, OUTPUT);
digitalWrite(ALARM_BUZZER,LOW);
tm1637.set(3); //Regler la brillance moyenne, 0(faible)-7(maxi)
tm1637.init();
Serial.println("TickShield multiplateforme ");
tm1637.point(0); //1 ou 0
Disp[0] = 10; //chiffres 0-9 puis A-F avec 10-15
Disp[1] = 11;
Disp[2] = 12;
Disp[3] = 13;
tm1637.display(Disp); //affiche "abcd"
delay(200);
//mettre en place le timer
MsTimer2::set(500, Timer2ISR); // 500ms period
MsTimer2::start();
}
void loop()
{
//Afficher l'heure HH:MM si le timer s'est activé
if (ClockPoint==1) //remise à jour 1 x/sec seulement
{get_time();
Serial.print(ClockPoint); //Faire clignotter le point d'horloge
}
// Lire l'état des 3 boutons, retourne un n° de pin
int16_t key_pressed = scanKey();
// Si on appuye, allumer une led témoin qui lui coorrespond
if(KEY_MENU == key_pressed)
{ //Appui sur la touche MENU
digitalWrite(led1, LOW); //tout éteindre
digitalWrite(led2, LOW);
digitalWrite(led3, LOW);
digitalWrite(led4, LOW);
//buzzer bip
digitalWrite(ALARM_BUZZER, HIGH);
delay(5); //bref bip
digitalWrite(ALARM_BUZZER, LOW);
}
if(KEY_UP == key_pressed)
{ //Appui sur la touche UP
digitalWrite(led1, HIGH); //allumer LEDS 1 et 2
digitalWrite(led2, HIGH);
//Mesure de température et affichage °C
affichage = getTemperature();
displayAffichage(affichage);
delay(500);
}
if(KEY_DOWN == key_pressed)
{ //Appui sur la touche DOWN
digitalWrite(led3, HIGH); //allumer LEDS 3 et 4
digitalWrite(led4, HIGH);
//Mesure de lumière et affichage
affichage = getLightIntensity(); //Mesurer lumière
//De 20 à 250 environ
Serial.print(affichage);
Serial.print(" sur ecran");
displayAffichage(affichage);
delay(500);
}
if(key_pressed > 0)delay(200);
//Allumer les 4 leds
//digitalWrite(led1, HIGH);
//digitalWrite(led2, HIGH);
//digitalWrite(led3, HIGH);
//digitalWrite(led4, HIGH);
} //Fin de boucle principale
// ==============Les fonctions ==========
//===== Fonction Scan_KEY surveille les 3 boutons
int16_t scanKey()
{ //Appuyer un bouton passe sa sortie à 0
int16_t pin_number = -1;
if(digitalRead(KEY_MENU) == LOW)
{
delay(20); //anti rebond
if(digitalRead(KEY_MENU) == LOW)
{
pin_number = KEY_MENU;
}
Serial.println("Appui sur KEY_MENU");
}
else if(digitalRead(KEY_UP) == LOW)
{
delay(20);
if(digitalRead(KEY_UP) == LOW)
{
pin_number = KEY_UP;
}
Serial.println("Appui sur KEY_UP");
}
else if(digitalRead(KEY_DOWN) == LOW)
{
delay(20); //Anti rebond
if(digitalRead(KEY_DOWN) == LOW)
{
pin_number = KEY_DOWN;
}
Serial.println("Appui sur KEY_DOWN");
}
return pin_number; //-1 si rien d'appuyé
}
// ======= Fonction getTemperature
int8_t getTemperature()
{
float temp,resistance;
int a;
int B = 3975;
a = analogRead(TEMPERATURE_SENSOR);
resistance = (float)(1023-a)*10000/a;
temp = 1/(log(resistance/10000)/B+1/298.15)-273.15;
Serial.print(temp);
Serial.println(" temperature");
return (int8_t)temp; // -40 à 125 degres
}
// ======= Fonction displayTemperature
void displayAffichage(float affichage)
{
int8_t temp[4];
int affichage_int = (int)affichage; //Arrondi entier
if(affichage_int < 0)
{
temp[0] = 16; //Signe -
affichage_int = abs(affichage_int);
}
else if(affichage_int < 100)temp[0] = 17; //blanc
else temp[0] = affichage_int/100;
affichage_int %= 100;
temp[1] = affichage_int / 10;
temp[2] = affichage_int % 10;
temp[3] = 17; // blanc //12 pour 'C' celsius
tm1637.point(0); //1 ou 0
tm1637.display(temp);
}
//=====getLightIntensity
float getLightIntensity()
{
int sensorValue = analogRead(LIGHT_SENSOR);
float rsensor;
rsensor=(float)(1023-sensorValue)*10/sensorValue;
Serial.print(rsensor);
Serial.println(" lumiere");
return rsensor;
}
//======= get_time RTC
void get_time()
{
byte second, minute, hour, dayOfWeek, dayOfMonth, month, year;
Wire.beginTransmission(DS1307_I2C_ADDRESS); // Ouvrir I2C en mode écriture
Wire.write((byte)0x00); // Mettre le pointeur de registre sur (0x00)
Wire.endTransmission(); // Fin de Write Transmission
Wire.requestFrom(DS1307_I2C_ADDRESS, 7); // Ouvrire I2C line en modeenvoi
second = bcdToDec(Wire.read() & 0x7f); // lire 7 bytes de data
minute = bcdToDec(Wire.read());
hour = bcdToDec(Wire.read() & 0x3f);
dayOfWeek = bcdToDec(Wire.read());
dayOfMonth = bcdToDec(Wire.read());
month = bcdToDec(Wire.read());
year = bcdToDec(Wire.read());
//Serial.println("heure");
Serial.print(dayOfWeek);
Serial.print(" - ");
Serial.print(dayOfMonth);
Serial.print("/");
Serial.print(month);
Serial.print("/");
Serial.print(year);
Serial.print(" ");
Serial.print(hour);
Serial.print(":");
Serial.print(minute);
Serial.print(":");
Serial.println(second);
//Puis afficher HH:MM ou MM:SS sur 7 segments
int8_t affiche_heure[4];
affiche_heure[0] =(int) minute /10;
affiche_heure[1] = (int) minute % 10;
affiche_heure[2]=(int) second /10;
affiche_heure[3]=(int) second % 10;
/*
affiche_heure[0] =(int) hour /10;
affiche_heure[1] = (int) hour % 10;
affiche_heure[2]=(int) minute /10;
affiche_heure[3]=(int) minute % 10;
*/
tm1637.display(affiche_heure);
//delay(100);
}
// ====== Convertir binary coded decimal en normal decimal number
byte bcdToDec(byte val)
{
return ( (val/16*10) + (val%16) );
}
// ==== Timer appelé 2x/sec
void Timer2ISR()
{
// halfsecond ++;
ClockPoint = (~ClockPoint) & 0x01; //Sert aussi de flag 1Hz
tm1637.point(ClockPoint); //1 ou 0 qui clignotte 2x/sec
}
Cet exemple de programme affiche lors de l'initialisation "ABCD" sur l'écran, il éclaire les LEDS témoins et lit les entrées des boutons de menu.
Les valeurs de température et de photo résistances sont affichées sur l'écran, ainsi que l'heure RTC.
- Bouton gauche = reset des 4 leds
- Bouton central = affiche la mesure de température, et allume les 2 leds rouges.
- Bouton droit = affiche la mesure de la photo résistance, et allume les 2 leds bleu et verte.
- Le reste du temps, affichage l'heure MM:SS du module RTC et le point central clignote 2x/sec.
Vous pouvez vous en inspirer pour vos propres projets.
Références
Un tutoriel (en anglais) http://www.seeedstudio.com/wiki/Tick_Tock_Shield_Kit
Librairies http://www.seeedstudio.com/wiki/File:Ti ... raries.zip
