Led 8 mm RGB Grove 104030006 / 104020048 – Version 2.00

–

Mise à jour le 15/02/2020 – Rubrique traitant du module led RGB 8 mm Grove , en particulier sur Arduino méga et nano . Nous traitons des 2 versions 104030006 / 104020048

Led RGB modéle 104030006

Sommaire :

Définition du codage RGB
Description technique du module RGB Grove 104030006
Installation de la bibliothèque ChainableLED
Intégration de la bibliothèque ChainableLED dans votre programme
Comment choisir une couleur rapidement ?
Exemple de programme .
- Programme minimum pour le fonctionnement des Led RGB Grove ( mode RGB ) avec tutoriel vidéo .
- Fonctionnement des Led RGB Grove ( mode HSB ) . avec tutoriel vidéo .
- Défilement de toutes les couleurs
- Programme qui vous permettra de choisir le spectre lumineux en RGB
- Comment choisir plusieurs spectres lumineux par l’intermédiaire de 3 boutons ?
- Programme simulant le battement du cœur par l’incrémentation de la valeur de la luminosité.
- Programme simulant le battement du cœur par l’incrémentation de la valeur de la luminosité avec modification de la vitesse en fonction de l’effort
- Programme sur Arduino nano ( en cours )
  - Matériel nécessaire
  - Programme
Retour au menu tutoriel .

Retour au sommaire

Définition du codage RGB

Rouge, vert, bleu, abrégé en RVB ou en RGB, de l’anglais « Red, Green, Blue » est, des systèmes de codage informatique des couleurs, le plus proche du matériel. Les écrans d’ordinateurs reconstituent une couleur parsynthèse additive à partir de trois couleurs primaires, un rouge, un vert et un bleu, formant sur l’écran une mosaïque trop petite pour être aperçue. Le codage RVB indique une valeur pour chacune de ces couleurs primaires.

Retour au sommaire

Description technique du module RGB Grove 104030006 et du modéle 104020048

Ce module led RGB 8 mm Grove , permet d’obtenir une couleur au choix à partir d’une sortie d’un microcontrôleur (Arduino, Seeeduino, etc.). Possibilité de mettre jusqu’à 1024 modules en cascade.

Caractéristiques et spécificités du modéle 104030006

Tension de fonctionnement : 5V
Courant de fonctionnement : 20mA
Protocole de communication : Serial
Interface : compatible Grove .Connectique non compatible avec Tinker Kit
Couleur : RGB
Dimensions : 20 x 20 x 25 mm
Référence Seeedstudio : 104030006 (remplace COM53140P)

Caractéristiques et spécificités du modéle 104020048 Version 2.00

Interface : série compatible Grove
Alimentation : 5 Vcc
Consommation : 20 mA
Couleur : RGB
Dimensions : 40 x 20 x 15 mm
Température de fonctionnement : -40 à 85 ℃
Version : 2.0
Référence Seeedstudio : 104020048 (remplace 104030006)

A savoir :

La version 2.00 ( 104020048 ) du point de vue fonctionnement est identique à la Version 1.00 (104030006 ) .La seule différence notable se trouve sur la partie du circuit imprimé, il est plus grand que la version 1.00. Cette modification a été faite pour que les câbles ne soient plus tordus.

Information de Seeedstudio .

Retour au sommaire

Installation de la bibliothèque ChainableLED

Prenez la dernière version de la section de téléchargement de GitHub. (https://github.com/pjpmarques/ChainableLED/downloads
Décompressez le fichier dans la bibliothèques IDE Arduino.

–

Retour au sommaire

Intégration de la bibliothèque ChainableLED

bibliothèque Arduino compatible avec Grove chainable LED et la puce P9813. Il permet de contrôler une chaîne de LED individuellement. Prise en charge des espaces de couleurs RVB et HSB pour régler la couleur de chaque LED individuellement.

Attention dans certaine version la fonction leds . init () ; est obligatoire

// à mettre dans la fonction setup

void  setup () 
{ 
 // initialisation du réseau de led  
 leds . init (); 
}

// à mettre dans la fonction setup

void setup ()

{

// initialisation du réseau de led

leds . init ();

}

Retour au sommaire

Comment choisir une couleur rapidement ?

Utilisation du logiciel Paint : Paint est un programme de dessin qui vous permet de créer des dessins ou de modifier des images numériques, il vous permet aussi d’enregistrer des fichiers d’images à l’aide de différents formats de fichier.

1 -Démarrer le logiciel Paint de Windows ( voici la procédure pour Windows 7 )
Pour ouvrir Paint, cliquez sur le bouton Démarrer, sur Tous les programmes, sur Accessoires, puis sur Paint.
ou également
Vous pouvez ouvrir Paint en procédant comme suit. Cliquez sur le bouton Démarrer. Dans la zone de recherche, tapez Paint, puis, dans la liste des résultats, double-cliquez sur Paint.
Apres la manipulation vous devez vous trouvez dans cette situation :

2- Cliquez sur l’icone modifier les couleurs dans la barre de taches

3- Vous devez obtenir le résultat ci-dessous

4-Choisissez la couleur que vous voulez obtenir à l’aide de la souris , vous obtiendrez des chiffres dans les rectangles intitulés teinte , Satur , Lum .Ensuite opérer une simple règle de 3 et vous aurez les valeurs à insérer dans le programme .
Voir l’exemple ci-dessous

/*
 * 
 * 
 * Le 17/04/2016
 * RedOhm par Mazelin Hervé
 * 
 *  Ce programme affiche la meme couleur  sur toutes les LED
 *  connecter
 *  
 *  ne pas oublier de charger la librairie
 */
 
 
#include <ChainableLED.h>
 
// Definit le nombre de LED utilisé
#define NUM_LEDS  4
 
// Definition des broches 
ChainableLED leds(6, 7, NUM_LEDS);

/* 
 *   Affectation des variables et initialisation
 *  
 *  On obtient la valeur 0.48 en opérant une simple 
 *  régle de 3 
 *  Exemple 
 *  Pour la teinre  124/255 = 0.48
 *  Pour la saturation  229/255= 0.89
 *  Pour la luminosité 131/255 = 0.51
 *  Ce qui correspond à la couleur choisie sur Paint
 */
 
// definition de la teinte ou couleur 0.83
float teinte = 0.48;
// definition de la saturation 0.89
float satur = 0.89;
// definition de la luminosité 
float lum=0.51;
boolean up = teinte;
 
void setup()
{
  
}
 
 

void loop()
{
  for (byte i=0; i<NUM_LEDS; i++)
    leds.setColorHSB(i, teinte, satur, lum);
    
  delay(50);

  

  
 
 
 
}

* Le 17/04/2016

* RedOhm par Mazelin Hervé

* Ce programme affiche la meme couleur sur toutes les LED

* connecter

* ne pas oublier de charger la librairie

#include <ChainableLED.h>

// Definit le nombre de LED utilisé

#define NUM_LEDS 4

// Definition des broches

ChainableLED leds(6, 7, NUM_LEDS);

* Affectation des variables et initialisation

* On obtient la valeur 0.48 en opérant une simple

* régle de 3

* Exemple

* Pour la teinre 124/255 = 0.48

* Pour la saturation 229/255= 0.89

* Pour la luminosité 131/255 = 0.51

* Ce qui correspond à la couleur choisie sur Paint

// definition de la teinte ou couleur 0.83

float teinte = 0.48;

// definition de la saturation 0.89

float satur = 0.89;

// definition de la luminosité

float lum=0.51;

boolean up = teinte;

void setup()

{

}

void loop()

{

for (byte i=0; i<NUM_LEDS; i++)

leds.setColorHSB(i, teinte, satur, lum);

delay(50);

}

–

Retour au sommaire

Programme minimum pour le fonctionnement des Led RGB Grove
(en mode RGB )

–

Tutoriel sur le principe de fonctionnement de la Led RGB Grove en mode RGB

–

Programme sur Arduino de la vidéo sur le mode de fonctionnement en RGB ci-dessus

//
//
// ****************************************
// * Programme minimun pour le            *
// *    fonctionnement des Led RGB        *
// *                                      *
// *                                      *
// *H-Mazelin                             *
// *le 14-10-2017                         *
// **************************************** 





//Cette bibliothèque vous permet de communiquer avec les led RGB de chez Grove
#include <ChainableLED.h>
 
// Definit le nombre de LED utilisées
#define NUM_LEDS  2
 
// Definition des broches derriere la commande 
// ChainableLED leds ( e ,f , g )
// choisir de preference 2 pin qui se suivent
// e = pin 6
// f = pin 7
// g = le nombre de led 
ChainableLED leds(6, 7, NUM_LEDS);

// --------------------------------------------------------------------
// Un programme Arduino doit impérativement contenir la fonction "setup"
// Elle ne sera exécuter une seule fois au démarrage du microcontroleur
// Elle sert à configurer globalement les entrées sorties
// --------------------------------------------------------------------
void setup()
{
  
}

// ----------------------------------------------------------------------
// Le programme principal s’exécute par une boucle infinie appelée Loop () 
// ----------------------------------------------------------------------
void loop ()

{
  

 // Envoie des informations suivantes apres la commande 
 // leds.setColorRGB ( a , b , c ,d )
 // a = le numero de la led on commence toujours à l'adresse 0
 // b = la valeur de la couleur rouge  " 0 "
 // c = la valeur de la couleur verte  " 0 "
 // d = la valeur de la couleur bleu   " 0 " 
 leds.setColorRGB(0, 15,156,7);
 leds.setColorRGB(1, 248,16,97);
 // une petite tempo de stabilisation de 10ms 
 delay(10); 
}

// ****************************************

// * Programme minimun pour le *

// * fonctionnement des Led RGB *

// * *

// *H-Mazelin *

// *le 14-10-2017 *

// ****************************************

//Cette bibliothèque vous permet de communiquer avec les led RGB de chez Grove

#include <ChainableLED.h>

// Definit le nombre de LED utilisées

#define NUM_LEDS 2

// Definition des broches derriere la commande

// ChainableLED leds ( e ,f , g )

// choisir de preference 2 pin qui se suivent

// e = pin 6

// f = pin 7

// g = le nombre de led

ChainableLED leds(6, 7, NUM_LEDS);

// --------------------------------------------------------------------

// Un programme Arduino doit impérativement contenir la fonction "setup"

// Elle ne sera exécuter une seule fois au démarrage du microcontroleur

// Elle sert à configurer globalement les entrées sorties

// --------------------------------------------------------------------

void setup()

{

}

// ----------------------------------------------------------------------

// Le programme principal s’exécute par une boucle infinie appelée Loop ()

// ----------------------------------------------------------------------

void loop ()

{

// Envoie des informations suivantes apres la commande

// leds.setColorRGB ( a , b , c ,d )

// a = le numero de la led on commence toujours à l'adresse 0

// b = la valeur de la couleur rouge " 0 "

// c = la valeur de la couleur verte " 0 "

// d = la valeur de la couleur bleu " 0 "

leds.setColorRGB(0, 15,156,7);

leds.setColorRGB(1, 248,16,97);

// une petite tempo de stabilisation de 10ms

delay(10);

}

Retour au sommaire Retour à la page tuto

Programme minimum pour le fonctionnement des Led RGB Grove (en mode HSB )

–

Programme sur Arduino de la vidéo sur le mode de fonctionnement en HSB ci-dessus

Attention : Le code pour piloter en HSB a changé avec la bibliothéque ( en date du 15/02/2020). Il faut écrire maintenant HSL au lieu de HSB

Exemple : leds.setColorHSL(0, teinte , satur, lum);

//
// ****************************************
// * Programme minimun pour le            *
// *    fonctionnement des Led RGB        *
// *                                      *
// *                                      *   
// *            en mode HSB               *
// *H-Mazelin                             *
// *le 16-10-2017                         *
// **************************************** 
 
 
//Cette bibliothèque vous permet de communiquer avec les led RGB de chez Grove
#include <ChainableLED.h>
 
// Definit le nombre de LED utilisé
#define NUM_LEDS  4
 
// Definition des broches derriere la commande 
// ChainableLED leds ( e ,f , g )
// choisir de preference 2 pin qui se suivent
// e = pin 6
// f = pin 7
// g = le nombre de led 
ChainableLED leds(6, 7, NUM_LEDS);
 

 
// --------------------------------------------------------------------
// Un programme Arduino doit impérativement contenir la fonction "setup"
// Elle ne sera exécuter une seule fois au démarrage du microcontroleur
// Elle sert à configurer globalement les entrées sorties
// --------------------------------------------------------------------
void setup()
{
  
}
 
 
// ----------------------------------------------------------------------
// Le programme principal s’exécute par une boucle infinie appelée Loop () 
// ---------------------------------------------------------------------- 
void loop()
{
  

 
//   Affectation des variables et initialisation
//  
//  On obtient la valeur 0.48 en opérant une simple 
//  régle de 3 
//  Exemple 
//  Pour la teinre  124/255 = 0.48
//  Pour la saturation  229/255= 0.89
//  Pour la luminosité 131/255 = 0.51
//  Ce qui correspond à la couleur choisie sur Paint
 

// definition de la teinte ou couleur 0.83
float teinte = 0.48;
// definition de la saturation 0.89
float satur = 0.89;
// definition de la luminosité 
float lum=0.51;

 // Envoie des informations suivantes apres la commande 
 // leds.setColorHSB ( a , b , c ,d )
 // a = le numero de la led on commence toujours à l'adresse 0
 // b = la valeur de la teinte  ->  paramétre a virgule flotante
 // c = la valeur de la saturation -> paramétre a virgule flotante
 // d = la valeur de la lumineusité -> paramétre a virgule flotante 
leds.setColorHSB(0, teinte , satur, lum);
 // une petite tempo de stabilisation de 10ms   
delay (10);   
   
 
}

// ****************************************

// * Programme minimun pour le *

// * fonctionnement des Led RGB *

// * *

// * en mode HSB *

// *H-Mazelin *

// *le 16-10-2017 *

// ****************************************

//Cette bibliothèque vous permet de communiquer avec les led RGB de chez Grove

#include <ChainableLED.h>

// Definit le nombre de LED utilisé

#define NUM_LEDS 4

// Definition des broches derriere la commande

// ChainableLED leds ( e ,f , g )

// choisir de preference 2 pin qui se suivent

// e = pin 6

// f = pin 7

// g = le nombre de led

ChainableLED leds(6, 7, NUM_LEDS);

// --------------------------------------------------------------------

// Un programme Arduino doit impérativement contenir la fonction "setup"

// Elle ne sera exécuter une seule fois au démarrage du microcontroleur

// Elle sert à configurer globalement les entrées sorties

// --------------------------------------------------------------------

void setup()

{

}

// ----------------------------------------------------------------------

// Le programme principal s’exécute par une boucle infinie appelée Loop ()

// ----------------------------------------------------------------------

void loop()

{

// Affectation des variables et initialisation

// On obtient la valeur 0.48 en opérant une simple

// régle de 3

// Exemple

// Pour la teinre 124/255 = 0.48

// Pour la saturation 229/255= 0.89

// Pour la luminosité 131/255 = 0.51

// Ce qui correspond à la couleur choisie sur Paint

// definition de la teinte ou couleur 0.83

float teinte = 0.48;

// definition de la saturation 0.89

float satur = 0.89;

// definition de la luminosité

float lum=0.51;

// Envoie des informations suivantes apres la commande

// leds.setColorHSB ( a , b , c ,d )

// a = le numero de la led on commence toujours à l'adresse 0

// b = la valeur de la teinte -> paramétre a virgule flotante

// c = la valeur de la saturation -> paramétre a virgule flotante

// d = la valeur de la lumineusité -> paramétre a virgule flotante

leds.setColorHSB(0, teinte , satur, lum);

// une petite tempo de stabilisation de 10ms

delay (10);

}

Retour au sommaire

Défilement de toutes les couleurs

/*
 * 
 * 
 * 
 *  Ce programme fait défiler toutes les couleurs d'une manière uniforme
 *  
 *  
 *  ne pas oublier de charger la librairie
 */


#include <ChainableLED.h>

// Definit le nombre de LED utilisé
#define NUM_LEDS  4

// Definition des broches 
ChainableLED leds(6, 7, NUM_LEDS);

void setup()
{
  
}

// Affectation des variables et initialisation 
float couleur = 0.0;
boolean up = couleur;

void loop()
{
  for (byte i=0; i<NUM_LEDS; i++)
    leds.setColorHSB(i, couleur, 1.0, 0.5);
    
  delay(50);
    
  if (up)
    couleur+= 0.025;
  else
    couleur-= 0.025;
    
  if (couleur>=1.0 && up)
    up = false;
  else if (couleur<=0.0 && !up)
    up = true;
}

* Ce programme fait défiler toutes les couleurs d'une manière uniforme

* ne pas oublier de charger la librairie

#include <ChainableLED.h>

// Definit le nombre de LED utilisé

#define NUM_LEDS 4

// Definition des broches

ChainableLED leds(6, 7, NUM_LEDS);

void setup()

{

}

// Affectation des variables et initialisation

float couleur = 0.0;

boolean up = couleur;

void loop()

{

for (byte i=0; i<NUM_LEDS; i++)

leds.setColorHSB(i, couleur, 1.0, 0.5);

delay(50);

if (up)

couleur+= 0.025;

else

couleur-= 0.025;

if (couleur>=1.0 && up)

up = false;

else if (couleur<=0.0 && !up)

up = true;

}

–

Retour au sommaire

Programme qui vous permettra de choisir le spectre lumineux en RGB

Voilà un petit programme qui vous permettra de choisir le spectre lumineux qui vous intéresse.Mais la fonction première de ce programme est de vous faire mieux appréhender comment changer la couleur des LED RGB, comment choisir le nombre de Led, et surtout comment initialiser les Led RGB de chez Grove sur une carte Arduino .

La version ci-dessous fonctionne avec l’IDE Arduino 1.6.13

/* 
 * 
 * 
 * Programme pour choisir un spectre lumineux 
 * 
 * RedOhm  
 * 
 * 17/05/2017
 * 
 * Par Herve.Mazelin
 * 
 * 
 */

//Cette bibliothèque vous permet de communiquer avec les led RGB de chez Grove
#include <ChainableLED.h>

// Definit le nombre de LED utilisées
#define NUM_LEDS  4

// Definition des broches derriere la commande 
// ChainableLED leds ( e ,f , g )
// choisir de preference 2 pin qui se suivent
// e = pin 6
// f = pin 7
// g = le nombre de led 
ChainableLED leds(6, 7, NUM_LEDS);



void setup()
{
  // initialisation de l'ensemble led,cette instruction est obligatoire
  leds.init();
}


void loop()
{
  
  // creation d'un boucle pour valider chaque led rgb 
  // entre les parentheses,3 parametres sont à donner 
  // exemple for ( x , y , z )
  // x = la création de la variable  dans notre cas " boucle=0 "
  // y = condition à laquelle la boucle s'arrete " boucle < 4 "
  // z = valeur d'incrementation de la boucle dans notre cas " de 1 "
  
  for (int boucle=0;boucle<4;boucle++)
  {
  // Envoie des informations suivantes apres la commande 
  // leds.setColorRGB ( a , b , c ,d )
  // a = le numero de la led on commence toujours à l'adresse 0
  // b = la valeur de la couleur rouge  " 245 "
  // c = la valeur de la couleur verte  " 254 "
  // d = la valeur de la couleur bleu   " 184 " 
  leds.setColorRGB(boucle, 245, 254,184);
  // une petite tempo de stabilisation de 10ms 
  delay(10);
  }
  
  

}

* Programme pour choisir un spectre lumineux

* RedOhm

* 17/05/2017

* Par Herve.Mazelin

//Cette bibliothèque vous permet de communiquer avec les led RGB de chez Grove

#include <ChainableLED.h>

// Definit le nombre de LED utilisées

#define NUM_LEDS 4

// Definition des broches derriere la commande

// ChainableLED leds ( e ,f , g )

// choisir de preference 2 pin qui se suivent

// e = pin 6

// f = pin 7

// g = le nombre de led

ChainableLED leds(6, 7, NUM_LEDS);

void setup()

{

// initialisation de l'ensemble led,cette instruction est obligatoire

leds.init();

}

void loop()

{

// creation d'un boucle pour valider chaque led rgb

// entre les parentheses,3 parametres sont à donner

// exemple for ( x , y , z )

// x = la création de la variable dans notre cas " boucle=0 "

// y = condition à laquelle la boucle s'arrete " boucle < 4 "

// z = valeur d'incrementation de la boucle dans notre cas " de 1 "

for (int boucle=0;boucle<4;boucle++)

{

// Envoie des informations suivantes apres la commande

// leds.setColorRGB ( a , b , c ,d )

// a = le numero de la led on commence toujours à l'adresse 0

// b = la valeur de la couleur rouge " 245 "

// c = la valeur de la couleur verte " 254 "

// d = la valeur de la couleur bleu " 184 "

leds.setColorRGB(boucle, 245, 254,184);

// une petite tempo de stabilisation de 10ms

delay(10);

}

–

Retour au sommaire

Comment choisir plusieurs spectres lumineux par l’intermédiaire de trois boutons.
– LED RGB Grove –

Voilà un programme qui vous permet de changer trois spectres lumineux par l’intermédiaire de trois simples boutons.
Ce programme nous permet de mettre en évidence et d’appliquer des fonctions ou des commandes particulières.

L’utilisation de la commande => Pullup
Avec cette fonction, il est possible d’utiliser un interrupteur ou un bouton-poussoir sans résistance de tirage ou même de piloter une entrée avec un simple fil sans pour autant créer des états électriques parasites.La seule difficulté est de bien intégrer que le comportement du mode de l’entrée fonctionnera en inverse

Utilisation des fonctions :
Une fonction ou plus communément appelé sous-programme, est un ensemble de lignes de code qui doit être exécuté à plusieurs endroits dans un même programme ce qui nous évite de réécrire plusieurs fois des lignes de code identique. Ou bien simplement de créer une architecture plus simple à lire

Ce programme a été réalisé avec la version : IDE 1.8.2 ( Arduino )
Carte pour le projet : Arduino Mega 2560

Plus d’information sur le commande : Pullup

/* 
 * 
 * 
 * Programme pour choisir 3 spectres lumineux 
 * 
 * RedOhm  
 * 
 * 17/05/2017
 * 
 * Par Herve.Mazelin
 * 
 * 
 */

//Cette bibliothèque vous permet de communiquer avec les led RGB de chez Grove
#include <ChainableLED.h>

// Definit le nombre de LED utilisées
#define NUM_LEDS  4

// Definition des broches derriere la commande 
// ChainableLED leds ( e ,f , g )
// choisir de preference 2 pin qui se suivent
// e = pin 6
// f = pin 7
// g = le nombre de led 
ChainableLED leds(6, 7, NUM_LEDS);


// Declaration des noms des entrée
// fil sur l'entree 14 permet de valider le spectre1
 int fil_14=14 ;
// fil sur l'entree 15 permet de valider le spectre2
 int fil_15=15 ;
// fil sur l'entree 16 permet de valider le spectre2
 int fil_16=16 ;

// variables pour enregistrer l'etat des l'entrées 14,15,16
 int entree_14 ;
 int entree_15 ;
 int entree_16 ;



// --------------------------------------------------------------------
// Un programme Arduino doit impérativement contenir la fonction "setup"
// Elle ne sera exécuter une seule fois au démarrage du microcontroleur
// Elle sert à configurer globalement les entrées sorties
// --------------------------------------------------------------------
void setup()
{
  // initialisation de l'ensemble led,eteinte

 eteindre();
 

 //Initialise les broches numérique 14,15,16 comme entrée avec la résistance
 //interne pull-up activé:

 pinMode (fil_14,INPUT_PULLUP);
 pinMode (fil_15,INPUT_PULLUP);
 pinMode (fil_16,INPUT_PULLUP);

 
}




// ----------------------------------------------------------------------
// Le programme principal s’exécute par une boucle infinie appelée Loop () 
// ----------------------------------------------------------------------
void loop()
{
  
 // Lit l"état de la broche 14 en entrée numérique, et renvoie la valeur
 // dans la variable entree_14
 entree_14=digitalRead(fil_14);
 entree_15=digitalRead(fil_15);
 entree_16=digitalRead(fil_16);
 
 
 // effectue le teste 
 if (entree_14==LOW)
 {
  // Appel de la fonction ->  spectre1
  spectre1();
  
 }

 else if (entree_15==LOW)
 {
  // Appel de la fonction ->  spectre2
  spectre2();
  
 }

 else if (entree_16==LOW)
 {
  // Appel de la fonction ->  spectre3
  spectre3();
  
 } 

 else
 {
 // eteindre les 4 led
 
  eteindre();
 }
 
   

}


/*
 *  la creation de la fonction -> spectre1
 *  
 *  a savoir : la creation d'une fonction est independante du programme 
 *  principal.Elle sera donc en dehors du programme principal 
 *  
 */

  
 void spectre1()
 {

 // creation d'un boucle pour valider chaque led rgb 
  // entre les parentheses,3 parametres sont à donner 
  // exemple for ( x , y , z )
  // x = la création de la variable  dans notre cas " boucle=0 "
  // y = condition à laquelle la boucle s'arrete " boucle < 4 "
  // z = valeur d'incrementation de la boucle dans notre cas " de 1 "
  
  for (int boucle=0;boucle<4;boucle++)
  {
  // Envoie des informations suivantes apres la commande 
  // leds.setColorRGB ( a , b , c ,d )
  // a = le numero de la led on commence toujours à l'adresse 0
  // b = la valeur de la couleur rouge  " 245 "
  // c = la valeur de la couleur verte  " 254 "
  // d = la valeur de la couleur bleu   " 184 " 
  leds.setColorRGB(boucle, 245, 254,184);
  // une petite tempo de stabilisation de 10ms 
  delay(10);
  }

  
 }

 /*
 *  la creation de la fonction -> spectre2
 *  
 *  a savoir : la creation d'une fonction est independante du programme 
 *  principal.Elle sera donc en dehors du programme principal 
 *  
 */

 void spectre2()
 {

 // creation d'un boucle pour valider chaque led rgb 
  // entre les parentheses,3 parametres sont à donner 
  // exemple for ( x , y , z )
  // x = la création de la variable  dans notre cas " boucle=0 "
  // y = condition à laquelle la boucle s'arrete " boucle < 4 "
  // z = valeur d'incrementation de la boucle dans notre cas " de 1 "
  
  for (int boucle=0;boucle<4;boucle++)
  {
  // Envoie des informations suivantes apres la commande 
  // leds.setColorRGB ( a , b , c ,d )
  // a = le numero de la led on commence toujours à l'adresse 0
  // b = la valeur de la couleur rouge  " 241 "
  // c = la valeur de la couleur verte  " 169 "
  // d = la valeur de la couleur bleu   " 200 " 
  leds.setColorRGB(boucle, 197,46,117);
  // une petite tempo de stabilisation de 10ms 
  delay(10);
  }

  
 }


  /*
 *  la creation de la fonction -> spectre2
 *  
 *  a savoir : la creation d'une fonction est independante du programme 
 *  principal.Elle sera donc en dehors du programme principal 
 *  
 */

 void spectre3()
 {

 // creation d'un boucle pour valider chaque led rgb 
  // entre les parentheses,3 parametres sont à donner 
  // exemple for ( x , y , z )
  // x = la création de la variable  dans notre cas " boucle=0 "
  // y = condition à laquelle la boucle s'arrete " boucle < 4 "
  // z = valeur d'incrementation de la boucle dans notre cas " de 1 "
  
  for (int boucle=0;boucle<4;boucle++)
  {
  // Envoie des informations suivantes apres la commande 
  // leds.setColorRGB ( a , b , c ,d )
  // a = le numero de la led on commence toujours à l'adresse 0
  // b = la valeur de la couleur rouge  " 55 "
  // c = la valeur de la couleur verte  " 132 "
  // d = la valeur de la couleur bleu   " 132 " 
  leds.setColorRGB(boucle, 55,132,132);
  // une petite tempo de stabilisation de 10ms 
  delay(10);
  }

  
 }

  /*
 *  la creation de la fonction -> eteindre 
 *  
 *  a savoir : la creation d'une fonction est independante du programme 
 *  principal.Elle sera donc en dehors du programme principal 
 *  
 *  cette fonction comme son nom l’indique nous permet d’éteindre
 *  les LED RGB . Il suffit pour cela de mettre dans la commande 
 *  3 chiffres zero leds.setColorRGB(boucle, 0,0,0);
 */




 

 void eteindre()
 {

 // creation d'un boucle pour valider chaque led rgb 
  // entre les parentheses,3 parametres sont à donner 
  // exemple for ( x , y , z )
  // x = la création de la variable  dans notre cas " boucle=0 "
  // y = condition à laquelle la boucle s'arrete " boucle < 4 "
  // z = valeur d'incrementation de la boucle dans notre cas " de 1 "
  
  for (int boucle=0;boucle<4;boucle++)
  {
  // Envoie des informations suivantes apres la commande 
  // leds.setColorRGB ( a , b , c ,d )
  // a = le numero de la led on commence toujours à l'adresse 0
  // b = la valeur de la couleur rouge  " 0 "
  // c = la valeur de la couleur verte  " 0 "
  // d = la valeur de la couleur bleu   " 0 " 
  leds.setColorRGB(boucle, 0,0,0);
  // une petite tempo de stabilisation de 10ms 
  delay(10);
  }

  
 }

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

* Programme pour choisir 3 spectres lumineux

* RedOhm

* 17/05/2017

* Par Herve.Mazelin

//Cette bibliothèque vous permet de communiquer avec les led RGB de chez Grove

#include <ChainableLED.h>

// Definit le nombre de LED utilisées

#define NUM_LEDS 4

// Definition des broches derriere la commande

// ChainableLED leds ( e ,f , g )

// choisir de preference 2 pin qui se suivent

// e = pin 6

// f = pin 7

// g = le nombre de led

ChainableLED leds(6, 7, NUM_LEDS);

// Declaration des noms des entrée

// fil sur l'entree 14 permet de valider le spectre1

int fil_14=14 ;

// fil sur l'entree 15 permet de valider le spectre2

int fil_15=15 ;

// fil sur l'entree 16 permet de valider le spectre2

int fil_16=16 ;

// variables pour enregistrer l'etat des l'entrées 14,15,16

int entree_14 ;

int entree_15 ;

int entree_16 ;

// --------------------------------------------------------------------

// Un programme Arduino doit impérativement contenir la fonction "setup"

// Elle ne sera exécuter une seule fois au démarrage du microcontroleur

// Elle sert à configurer globalement les entrées sorties

// --------------------------------------------------------------------

void setup()

{

// initialisation de l'ensemble led,eteinte

eteindre();

//Initialise les broches numérique 14,15,16 comme entrée avec la résistance

//interne pull-up activé:

pinMode (fil_14,INPUT_PULLUP);

pinMode (fil_15,INPUT_PULLUP);

pinMode (fil_16,INPUT_PULLUP);

}

// ----------------------------------------------------------------------

// Le programme principal s’exécute par une boucle infinie appelée Loop ()

// ----------------------------------------------------------------------

void loop()

{

// Lit l"état de la broche 14 en entrée numérique, et renvoie la valeur

// dans la variable entree_14

entree_14=digitalRead(fil_14);

entree_15=digitalRead(fil_15);

entree_16=digitalRead(fil_16);

// effectue le teste

if (entree_14==LOW)

{

// Appel de la fonction -> spectre1

spectre1();

}

else if (entree_15==LOW)

{

// Appel de la fonction -> spectre2

spectre2();

}

else if (entree_16==LOW)

{

// Appel de la fonction -> spectre3

spectre3();

}

else

{

// eteindre les 4 led

eteindre();

}

* la creation de la fonction -> spectre1

* a savoir : la creation d'une fonction est independante du programme

* principal.Elle sera donc en dehors du programme principal

void spectre1()

{

// creation d'un boucle pour valider chaque led rgb

// entre les parentheses,3 parametres sont à donner

// exemple for ( x , y , z )

// x = la création de la variable dans notre cas " boucle=0 "

// y = condition à laquelle la boucle s'arrete " boucle < 4 "

// z = valeur d'incrementation de la boucle dans notre cas " de 1 "

for (int boucle=0;boucle<4;boucle++)

{

// Envoie des informations suivantes apres la commande

// leds.setColorRGB ( a , b , c ,d )

// a = le numero de la led on commence toujours à l'adresse 0

// b = la valeur de la couleur rouge " 245 "

// c = la valeur de la couleur verte " 254 "

// d = la valeur de la couleur bleu " 184 "

leds.setColorRGB(boucle, 245, 254,184);

// une petite tempo de stabilisation de 10ms

delay(10);

}

* la creation de la fonction -> spectre2

* a savoir : la creation d'une fonction est independante du programme

* principal.Elle sera donc en dehors du programme principal

void spectre2()

{

// creation d'un boucle pour valider chaque led rgb

// entre les parentheses,3 parametres sont à donner

// exemple for ( x , y , z )

// x = la création de la variable dans notre cas " boucle=0 "

// y = condition à laquelle la boucle s'arrete " boucle < 4 "

// z = valeur d'incrementation de la boucle dans notre cas " de 1 "

for (int boucle=0;boucle<4;boucle++)

{

// Envoie des informations suivantes apres la commande

// leds.setColorRGB ( a , b , c ,d )

// a = le numero de la led on commence toujours à l'adresse 0

// b = la valeur de la couleur rouge " 241 "

// c = la valeur de la couleur verte " 169 "

// d = la valeur de la couleur bleu " 200 "

leds.setColorRGB(boucle, 197,46,117);

// une petite tempo de stabilisation de 10ms

delay(10);

}

* la creation de la fonction -> spectre2

* a savoir : la creation d'une fonction est independante du programme

* principal.Elle sera donc en dehors du programme principal

void spectre3()

{

// creation d'un boucle pour valider chaque led rgb

// entre les parentheses,3 parametres sont à donner

// exemple for ( x , y , z )

// x = la création de la variable dans notre cas " boucle=0 "

// y = condition à laquelle la boucle s'arrete " boucle < 4 "

// z = valeur d'incrementation de la boucle dans notre cas " de 1 "

for (int boucle=0;boucle<4;boucle++)

{

// Envoie des informations suivantes apres la commande

// leds.setColorRGB ( a , b , c ,d )

// a = le numero de la led on commence toujours à l'adresse 0

// b = la valeur de la couleur rouge " 55 "

// c = la valeur de la couleur verte " 132 "

// d = la valeur de la couleur bleu " 132 "

leds.setColorRGB(boucle, 55,132,132);

// une petite tempo de stabilisation de 10ms

delay(10);

}

* la creation de la fonction -> eteindre

* a savoir : la creation d'une fonction est independante du programme

* principal.Elle sera donc en dehors du programme principal

* cette fonction comme son nom l’indique nous permet d’éteindre

* les LED RGB . Il suffit pour cela de mettre dans la commande

* 3 chiffres zero leds.setColorRGB(boucle, 0,0,0);

void eteindre()

{

// creation d'un boucle pour valider chaque led rgb

// entre les parentheses,3 parametres sont à donner

// exemple for ( x , y , z )

// x = la création de la variable dans notre cas " boucle=0 "

// y = condition à laquelle la boucle s'arrete " boucle < 4 "

// z = valeur d'incrementation de la boucle dans notre cas " de 1 "

for (int boucle=0;boucle<4;boucle++)

{

// Envoie des informations suivantes apres la commande

// leds.setColorRGB ( a , b , c ,d )

// a = le numero de la led on commence toujours à l'adresse 0

// b = la valeur de la couleur rouge " 0 "

// c = la valeur de la couleur verte " 0 "

// d = la valeur de la couleur bleu " 0 "

leds.setColorRGB(boucle, 0,0,0);

// une petite tempo de stabilisation de 10ms

delay(10);

}

Retour au sommaire

Programme simulant le battement du cœur par l’incrémentation de la valeur de la luminosité

//
//
//
// ****************************************************
// *                                                  *
// * Programme simulant le battement du cœur          *
// *  par l’incrémentation de la valeur de la         *
// *                     de la luminosité             *
// *                                                  *
// * Et avec modification de la vitesse               *    
// *          de battement du ceur                    *
// *                 en fonction de l’effort          *
// *                                                  *
// * Le 28/10/2017                                    *
// * Herve Mazelin                                    *
// ****************************************************
 
#include <ChainableLED.h>
 
// Definit le nombre de LED utilisé
#define NUM_LEDS  1
 
// Definition des broches 
ChainableLED leds(6, 7, NUM_LEDS);
 
 
/* 
 *   Affectation des variables et initialisation
 *  
 *  On obtient la valeur 0.48 en opérant une simple 
 *  régle de 3 
 *  Exemple 
 *  Pour la teinre  2/255 = 0.007
 *  Pour la saturation  235/255= 0.92
 *  Pour la luminosité 104/255 = 0.407
 *  Ce qui correspond à la couleur choisie sur Paint
 */
 
 
// definition de la teinte ou couleur 0.83
float teinte = 0.;
// definition de la saturation 0.89
float satur = 0.92;
// definition de la luminosité 
float lum=0.41;
 
 
// variable du type int pour stocker la valeur de battement du coeur
int effort_coeur ;
// déclaration de l'entrée analogique 
// ou se trouve le module potentiometre Grove
// qui va nous permettre de simuler la consommation en courant du robot 
// ou si vous preferez les efforts que ferai un humain  
int potar_pin_efforts = 2; 
 
 
// --------------------------------------------------------------------
// Un programme Arduino doit impérativement contenir la fonction "setup"
// Elle ne sera exécuter une seule fois au démarrage du microcontroleur
// Elle sert à configurer globalement les entrées sorties
// --------------------------------------------------------------------
void setup() {
 
  
  
}
 
 
 
// ----------------------------------------------------------------------
// Le programme principal s’exécute par une boucle infinie appelée Loop () 
// ---------------------------------------------------------------------- 
 
void loop()
{
 
// lis la valeur de la tension analogique présente sur la broche 2
// et introduit le resultat dans la variable "effort_coeur"
effort_coeur = analogRead(potar_pin_efforts);
// la valeur du potentiometre est comprise entre 0 et 1023
// Etalonnage de la valeur du potentiometre en "effort_coeur"
// valeur de temps comprise de 0 a 45 milliseconde
// pour cela on utilise la fonction Map
// map (variable ,valeur basse de depart,valeur haute de depart ,new valeur basse, new valeur haute )
// valeur basse de depart = 0
// valeur haute de depart = 1023
// new valeur basse = 0
// new valeur haute = 45
effort_coeur =map( effort_coeur ,0,1023,0,300);
 
 
 
// Boucles nous permettant d’incrémenter la valeur de la
// variable lum
for ( int i=0 ; i<30 ;i++)
  {
  // Incrémentations de la variable lum  
  lum =lum+0.01;
  // Envoie des informations suivantes apres la commande 
  // leds.setColorHSB ( a , b , c ,d )
  // a = le numero de la led on commence toujours à l'adresse 0
  // b = la valeur de la teinte  ->  paramétre a virgule flotante
  // c = la valeur de la saturation -> paramétre a virgule flotante
  // d = la valeur de la lumineusité -> paramétre a virgule flotante 
  leds.setColorHSB(0, teinte, satur, lum);
  // Temps d’attente pour le transfert d’informations sur chaque LED  
  delay(10);
  }

  
  // la fonction delay dans ce cas représente la vitesse 
  // de battement du cœur
  delay(350-effort_coeur);
  //Forçage la valeur de la variable à 0.41
  lum=0.41;


}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

// ****************************************************

// * *

// * Programme simulant le battement du cœur *

// * par l’incrémentation de la valeur de la *

// * de la luminosité *

// * *

// * Et avec modification de la vitesse *

// * de battement du ceur *

// * en fonction de l’effort *

// * *

// * Le 28/10/2017 *

// * Herve Mazelin *

// ****************************************************

#include <ChainableLED.h>

// Definit le nombre de LED utilisé

#define NUM_LEDS 1

// Definition des broches

ChainableLED leds(6, 7, NUM_LEDS);

* Affectation des variables et initialisation

* On obtient la valeur 0.48 en opérant une simple

* régle de 3

* Exemple

* Pour la teinre 2/255 = 0.007

* Pour la saturation 235/255= 0.92

* Pour la luminosité 104/255 = 0.407

* Ce qui correspond à la couleur choisie sur Paint

// definition de la teinte ou couleur 0.83

float teinte = 0.;

// definition de la saturation 0.89

float satur = 0.92;

// definition de la luminosité

float lum=0.41;

// variable du type int pour stocker la valeur de battement du coeur

int effort_coeur ;

// déclaration de l'entrée analogique

// ou se trouve le module potentiometre Grove

// qui va nous permettre de simuler la consommation en courant du robot

// ou si vous preferez les efforts que ferai un humain

int potar_pin_efforts = 2;

// --------------------------------------------------------------------

// Un programme Arduino doit impérativement contenir la fonction "setup"

// Elle ne sera exécuter une seule fois au démarrage du microcontroleur

// Elle sert à configurer globalement les entrées sorties

// --------------------------------------------------------------------

void setup() {

}

// ----------------------------------------------------------------------

// Le programme principal s’exécute par une boucle infinie appelée Loop ()

// ----------------------------------------------------------------------

void loop()

{

// lis la valeur de la tension analogique présente sur la broche 2

// et introduit le resultat dans la variable "effort_coeur"

effort_coeur = analogRead(potar_pin_efforts);

// la valeur du potentiometre est comprise entre 0 et 1023

// Etalonnage de la valeur du potentiometre en "effort_coeur"

// valeur de temps comprise de 0 a 45 milliseconde

// pour cela on utilise la fonction Map

// map (variable ,valeur basse de depart,valeur haute de depart ,new valeur basse, new valeur haute )

// valeur basse de depart = 0

// valeur haute de depart = 1023

// new valeur basse = 0

// new valeur haute = 45

effort_coeur =map( effort_coeur ,0,1023,0,300);

// Boucles nous permettant d’incrémenter la valeur de la

// variable lum

for ( int i=0 ; i<30 ;i++)

{

// Incrémentations de la variable lum

lum =lum+0.01;

// Envoie des informations suivantes apres la commande

// leds.setColorHSB ( a , b , c ,d )

// a = le numero de la led on commence toujours à l'adresse 0

// b = la valeur de la teinte -> paramétre a virgule flotante

// c = la valeur de la saturation -> paramétre a virgule flotante

// d = la valeur de la lumineusité -> paramétre a virgule flotante

leds.setColorHSB(0, teinte, satur, lum);

// Temps d’attente pour le transfert d’informations sur chaque LED

delay(10);

}

// la fonction delay dans ce cas représente la vitesse

// de battement du cœur

delay(350-effort_coeur);

//Forçage la valeur de la variable à 0.41

lum=0.41;

}

Retour au sommaire