Utilisation du protocope I2C

Voici un tutoriel un peu plus complet cette fois. Toujours à base du TCN75A, l’idée est ici de tester le protocole I2C. En effet, celui ci permet de mettre en parallèle plusieurs périphériques.

Nous allons donc mettre un écran LCD, le capteur de température et une horloge Tiny RTC, les trois fonctionnant avec le protocole I2C.

1. Pré requis

a. Librairies utilisées :

Wire.h : référence Arduinoexplications en Français

TCN75A.h : Github

RTClib.h : Github

U8glib.h : Wiki de la librairie

b. Connaissance utile :

Le tutoriel n°1 permet d’appréhender l’utilisation du capteur de température Tcn75A via le protocole I2C.

2. Objectif

Afficher sur l’écran les informations des capteurs; Un message qui défile de gauche à droite, date/heure et température relevée. Par défaut l’écran est éteint.

Un clic sur le bouton permettra d’afficher les informations à l’écran. Au bout de 5s l’écran s’éteint. Si avant la fin des 5s on clic, l’écran s’éteint.

On entend par clic la pression et le relâchement du bouton.

Afin de réaliser cette gestion, nous allons mettre en place un petit automate (Les automates évitent bien des problèmes liés à des événements).

3. Matériel utilisé

  • Arduino Uno Rev3
  • Capteur de température TCN75A : Datasheet
  • 0,96 pouces LCD OLED de 128 x 64 série I2C SPI IIC
  • Horloge Tiny RTC
  • Résistance de 10K Ohms et de 220 Ohms
  • 1 bouton poussoir
  • Quelques cables

4. Schéma

5. Programme

a. Extrait de code

Partie déclarative
#include <Wire.h> // librairie utilisant le protocole I2C / TWI (communication série sur 2 fils)
#include <RTClib.h> // Librairie pour l’utilisation de l’horloge temps réel.
#include <U8glib.h> // Librairie pour l’utilisation des écrans LCD
#include <TCN75A.h> // Librairie pour le capteur de température

/* DEFINITION DES CONSTANTES */
#define BTN_LIGHTLCD 2 // Définition du bouton d’allumage de l’écran LCD
#define LIGHTON_DURATION 5000 // Durée en milliseconde de l’affichage de l’écran

/* DECLARATION DES VARIABLES GLOBALES */
// Déclaration des différents composants
RTC_DS1307 cp_Timer; // Définition de l’objet Composant Timer Tiny RTC
U8GLIB_SSD1306_128X64 cp_Lcd(U8G_I2C_OPT_NONE | U8G_I2C_OPT_DEV_0); // Définition de l’écran
TCN75A cp_Temp; // Définition du capteur de température

// Variables d’animations : Scroll horizontal
int m_xoffset = 0; // Position en X de l’affichage du message.
int m_inc = 2; // Pas d’incrément pour la position du message.

// Variable d’état du bouton et de mesure du temps
int m_stateLightLcd; // Variable d’état de l’automate
int m_btnLightLcdState; // Variable d’état du bouton poussoir
long m_diffTime; // Différence temporelle pour mesure la durée d’affichage.
bool m_isTurnOnLcd = false; // Permet de définir si l’écran est allumé.

 

Quelques méthodes
/* Nom : SetLcdInfos
Description : Permet d’afficher les éléments sur l’écran LCD.
Paramètre : p_mes => Message à afficher et qui scroll.
p_date => Date
p_temp => température
Retour : aucun.
*/
void SetLcdInfos(String p_mes, DateTime p_date, float p_temp)
{
	// Boucle d’affichage
	cp_Lcd.firstPage();
	do {
		cp_Lcd.setPrintPos(m_xoffset, 10);
		cp_Lcd.print(p_mes); // Affichage du message (Animé).
		cp_Lcd.setPrintPos(0, 25);
		cp_Lcd.print(FormatDate(p_date, 1));// Affichage de la date
		cp_Lcd.setPrintPos(0, 40);
		cp_Lcd.print(« Il est  » + FormatDate(p_date, 2));// Affichage de l’heure
		cp_Lcd.setPrintPos(0, 55);
		cp_Lcd.print(« Il fait  » + FormatTemp(p_temp)); // Affichage de la température
	} while (cp_Lcd.nextPage());

	// Calcul de l’offset pour le scroll
	m_xoffset = m_xoffset + m_inc;
	if (m_xoffset <= -128 || m_xoffset >= 128)
	m_inc = -m_inc;
}

/* Nom : SetLcdInfos
Description : Automate permettant la gestion de l’affichage à partir du bouton.
Un clic = Appuyer et relacher.
Clic => Allumage écran pour LIGHTON_DURATION secondes
Clic pendant l’allumage => Eteindre l’écran
Les états.
0 : Etat de base écran éteint
1 : Etat appuyé sur bouton
2 : Etat relache du bouton
Paramètre : aucun.
Retour : aucun.
*/
void CheckBtn()
{
	long v_dif;
	m_btnLightLcdState = digitalRead(BTN_LIGHTLCD); //Rappel : bouton = 2

	if (m_btnLightLcdState == HIGH)
	{
		if(m_stateLightLcd == 0)
			m_stateLightLcd = 1;
	}
	else
	{
		if(m_stateLightLcd == 1)
			m_stateLightLcd = 2;
	}

	if (m_stateLightLcd == 2)
	{
		m_isTurnOnLcd = !m_isTurnOnLcd;
		m_stateLightLcd = 0;
		v_dif = millis() – m_diffTime;
		m_diffTime = millis();
	}
	if(m_stateLightLcd == 0)
		v_dif = millis() – m_diffTime;

	if (m_isTurnOnLcd)
		if (v_dif >= LIGHTON_DURATION)
			m_isTurnOnLcd = false;
	if (m_isTurnOnLcd)
		Serial.print(« Allume « );
	else
		Serial.print(« Etient « );
	Serial.print(« Depuis « );
	Serial.print(v_dif / 1000);
	Serial.println(« s »);
}
Le setup
void setup(void) {
	// On init le port série pour avoir une console.
	Serial.begin(9600);

	// Init du port I2C
	Wire.begin();

	// Init Tiny RTC pour obtenir l’horloge
	cp_Timer.begin();
	if (!cp_Timer.isrunning()) {
		Serial.println(« RTC is NOT running! »);
		// Cette ligne permet de définir la date et l’heure du Tin RTC si celle ci n’a jamais été initialisé.
		// Attention à ne pas le faire fréquemment, en effet le nombre d’écriture est limité (espérance de vie du composant).
		cp_Timer.adjust(DateTime(__DATE__, __TIME__));
	}

	// Init du capteur de température
	cp_Temp.begin();
	cp_Temp.set_address(0);
	cp_Temp.set_resolution(3);

	// Init de l’écran LCD
	cp_Lcd.sleepOff();
	cp_Lcd.setFont(u8g_font_unifont); // Définition de la fonte par défaut.
	if (cp_Lcd.getMode() == U8G_MODE_R3G3B2) {
		cp_Lcd.setColorIndex(255); // Blanc
	}
	else if (cp_Lcd.getMode() == U8G_MODE_GRAY2BIT) {
		cp_Lcd.setColorIndex(3); // intensité maximum
	}
	else if (cp_Lcd.getMode() == U8G_MODE_BW) {
		cp_Lcd.setColorIndex(1); // pixel on
	}
	else if (cp_Lcd.getMode() == U8G_MODE_HICOLOR) {
		cp_Lcd.setHiColorByRGB(255, 255, 255);
	}

	// Mise en place du bouton d’allumage de l’écran
	pinMode(BTN_LIGHTLCD, INPUT);

	m_stateLightLcd = 0;
	m_diffTime = millis();
}
Le loop
void loop(void) {
	// On récupère la date et l’heure
	DateTime v_now = cp_Timer.now();

	// Récupération de la température
	float v_t = cp_Temp.read();

	// Ecriture des informations sur le port Série
	SetSerialInfos(v_now, v_t);

	// Ecriture des informations sur l’écran Lcd
	if (m_isTurnOnLcd)
	{
		cp_Lcd.sleepOff();
		SetLcdInfos(« Bonjour Seb », v_now, v_t);
	}
	else
		cp_Lcd.sleepOn();

	// Automate de gestion du bouton.
	CheckBtn();
}

b. Source à télécharger

Tutoriel n°2 le .ino

6. Résultat

En Image

En vidéo

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Ce site utilise Akismet pour réduire les indésirables. En savoir plus sur comment les données de vos commentaires sont utilisées.