TickShield plateforme multi fonctions pour Arduino.

Utilisation de capteurs et composants électroniques avec Arduino.
Une fiche de tutoriel pour chaque.

TickShield plateforme multi fonctions pour Arduino.

Messagepar tiptop » Mer 19 Nov 2014 15:05

Le TickShield comporte un afficheur 4 chiffres avec des led, des boutons, un buzzer, une horloge, un thermomètre et un capteur de lumière.
Ce tutoriel présente un exemple détaillé d'utilisation de ces fonctions.
Image

Composants utilisés


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.

Image

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.

Image.Image.Image
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
tiptopboards - admin
Avatar de l’utilisateur
tiptop
Administrateur du site
 
Messages: 88
Inscription: Mar 13 Aoû 2013 20:38
Localisation: 38

Re: TickShield plateforme multi fonctions pour Arduino.

Messagepar fbedon » Dim 7 Mai 2017 16:58

Salut a tous,
j’essaie de mettre en œuvre un circuit TickShield.
au premier abord ça marche super, les exemples se compilent et s exécutent sans soucis.

Dans le détail, l'exemple RealTimeClock n'affiche pas les valeurs durant les modifications des paramètres, heures, alarme,...
l'instruction de mise à jour de l'afficheur tm1636.display(disp); est commenté dans le fichier TickShield.cpp, naturellement quand on le décommente ça plante...

Pour ton programme, Christian, tu mets un include vers le fichier TM1637.h, mais il n'est pas dans la bibliothèque, on trouve bien le TM1636.h, je vais essayer de remplacer.
Ca marche en remplaçant le nom dans l'include et dans le nom de la classe un peu plus loin.

il faut assi ajouter la fonction
byte decToBcd(byte val)
{
return ( (val/10*16) + (val%10) );
}


ainsi que les variables associées pour pouvoir faire la mise à l heure.

ce n'est pas vraiment pour les newbies ton exemple.

à suivre...
Fred
Avatar de l’utilisateur
fbedon
 
Messages: 14
Inscription: Mer 21 Mai 2014 19:56
Localisation: Grenoble

Re: TickShield plateforme multi fonctions pour Arduino.

Messagepar fbedon » Dim 28 Mai 2017 10:18

Salut à tous,
pour tous ceux qui comme moi pensent que la carte TickShield est une bonne base pour réaliser un programmateur, je propose de donner les correspondances pour utiliser une carte Arduino Méga qui dispose d'un nombre d'entrées sorties disponibles acceptables pour ce genre d'application.
TickShield Méga
2 __2
3 __3
4 __4
5 __5
6 __6
7 __7
8 __8
9 __9
10 __10
11 __11
A4 __ 20
A5 __ 21
GND __GND
5V __5V
3.3V __3.3V

Fred
Avatar de l’utilisateur
fbedon
 
Messages: 14
Inscription: Mer 21 Mai 2014 19:56
Localisation: Grenoble


Retourner vers Capteurs et composants

Qui est en ligne

Utilisateurs parcourant ce forum: Aucun utilisateur enregistré et 4 invités