まこと の ブログ

MaKoTo no burogu — Journal de bord…

Aller au contenu | Aller au menu | Aller à la recherche

WebRadioRéveilWifi -2-

Suite de l'étude précédente :

Nouveau billet d'étape, cette fois-ci concernant l'horloge, et je me rend compte que je n'ai pas encore présenté le projet complet, oups !
Bon je verrais ça plus tard avec un billet N° zero…

  • Donc après les quelques tests réalisés sur le Raspberry pi pour la partie WebRadio, on va s'occuper ici de la partie horloge.

Au départ je voulais la faire avec un µC Atmega, et puis comme ça sans trop réfléchir, je me suis procuré un Arduino.
Je n'avais jusqu'alors pas essayé, considérant que l’utilisation d'un µC était finalement la même chose, en bas niveau il s'entend.
Sauf que j'avais tord ! Pas sur le fond, puisque c'est bel et bien le cas, mais sur la forme. En effet programmer un AVR n'a rien de sexy, et lorsqu'on connaît mal le composant, il faut beaucoup de temps et de persévérance avant de savoir ce qu'il est possible de faire et d'en appréhender le fonctionnement, notamment le plus complexe pour moi qui ne suis pas codeur, la programmation.
Je me voyais donc mal barré, et s'il y a bien une chose fondamentale que j'ai apprise, c'est qu'il faut avant tout se faire plaisir pour avancer.
Il me fallait donc emprunter une voie différente, et de découvrir l'Arduino et son langage simplifié aura débloqué la situation.
J'ai donc été très surpris de parvenir à faire fonctionner mon horloge en à peine un week-end, fort des nombreux exemples et réalisations documentées en ligne.
j'aurais dû essayer Arduino plus tôt ^^;
J'ai ensuite pris plaisir à continuer de perfectionner mon système pour y ajouter des fonctionnalités, que je vais détailler ici.


Premiers essais, premières erreurs :

  • Le système d'affichage repose sur des registres à décalages. J'avais d'abord entrepris les 74HC164, car j'en avais sous la main.

Sauf que, voici le résultat :

Comme diraient nos amis anglo-saxon, ça « flicke », et ce à chaque boucle du programme, plus ou moins vite en fonction de sa vitesse d'exécution, que j'ai réglé ici à 1/4 de secondes pour qu'on voit bien le résultat.
J'ai perdu pas mal de temps à chercher dans mon code ce qui n'allait pas, avant de constater que ce comportement était dû à la nature du registre, qui ne dispose pas de fonction Latch permettant d'interrompre la transmission de donnée.

  • J'ai alors opté pour des 74HC595…

Le montage :

Voici le schéma structurel :
horloge-structurel-0.1.png

  • On a donc l'Arduino connecté à un module chronodot, et à 4 afficheurs 7 segments via des registres à décalages.

Oui j'ai omis volontairement de mettre des résistances de protection sur chaque segments, et les résistances de polarisation des transistors, je verrais ça plus tard.
Pour le moment c'est du prototype, donc voilà, et puis ces afficheurs mangent du 4,3V sur les 5V de l'alimentation, ce qui laisse très peu d'énergie néfaste aux diodes, d'autant qu'on va les utiliser en PWM.

  • La maquette sur plaque labo :

dsc00056.jpg dsc00070.jpg

  • Le composant DS3231, ainsi câblé forme le module chronodot, qu'il me suffit d'enficher dans une plaquette labo. Une library assez simple pour s'adresser à ce composant existe, il faut donc l'installer dans le logiciel Arduino.

dsc00074.jpg dsc00058.jpg

dsc00069.jpg

Le développement :

Ce qui me paraissait une montagne obscure et sombre à franchir, quoique bien éclairée par la plateforme Arduino n'a pas été franchie d'un seul coup, et le programme que vous trouverez plus loin s'est construit par petits bouts de codes que j'ai ensuite assemblés et fait évoluer, en m'aidant d'exemples Arduino pour l'affichage sur les 7 segments, et de l'exemple fournit avec la librairie pour le chronodot, le circuit électronique allant en se complexifiant.

Étape après étape on va se rapprocher de l'objectif :

  • Partie afficheurs,

- Allumer une led (exemple arduino).
- Allumer un afficheur.
- Afficher le chiffre de mon choix sur l'afficheur (datasheet 74HC164).
- Afficher un compte à rebours sur un afficheur.
- Ajouter un second afficheur, et afficher un nombre.
- Faire varier l'intensité d'une LED avec la PWM (exemple arduino).
- Modification du circuit avec transistor pour utilisation de la PWM avec les afficheurs.
- PWM fixée sur l'intensité de mon choix dans le code.

  • Module chronodot,

- Câblage du module chronodot et connexion à l'Arduino (datasheet DS3231).
- Récupération de l'heure et affichage dans la console série Arduino (exemple lib chronodot).

  • Affichage de l'heure,

Ça se complique, c'est le passage avec lequel j'ai eu le plus de mal et qui m'aura donné des rêves étrange entre samedi et dimanche.

- Affichage des secondes sur deux afficheurs (brainstorming).
- Simplification de ce code à l'aide d'un tableau.
- Fixé dans le code, affichage au choix, soit des heures, minutes ou secondes.

Bloqué sur le problème de flicker, fin du week end.

- Lundi, remplacement des 74HC164 pour les 74HC595, flicker out, ouf ^^
Plus tard,
- Ajout d'un bouton poussoir, allumer une led quand on le presse (exemple arduino).

Je suis resté un peu bloqué car je ne comprenais pas comment utiliser la librairie chronodot, alors qu'il suffit de décrypter le fichier Chronodot.h pour comprendre ce que la librairie permet de faire.

- Mise à l'heure le chronodot à l'aide de deux boutons poussoir.

  • La plaque labo étant trop étroite, câblage sur plaque d'essais à trou.

dsc00076.jpg dsc00077.jpg dsc00079.jpg dsc00080.jpg
- Affichage des heures et secondes, mise à l'heure manuelle ok.

  • PWM automatique,

- Câblage de la photodiode et affichage dans la console série Arduino de la valeur renvoyée par la diode (exemple arduino).
- Variation de la PWM en fonction de la valeur envoyée par la photodiode, dans le but de baisser l'intensité lumineuse des afficheurs dans la pénombre, et de l'augmenter quand il fait soleil.

C'est tout pour le moment !

  • Il me reste à voir comment implémenter le système pour les alarmes du réveil, et à communiquer certains événements avec la Raspberry et je pense que ce sera tout pour cette partie du projet.

Voici le programme, dont j'ai commenté chaque ligne afin de ne pas perdre les débutants.

/****** Domaine publique, youpi ! ******/
#include <Wire.h>       // Communication avec le RTC
#include "Chronodot.h"  // Fonctions du Chronodot

/****************/
/* Déclarations */
/****************/

/****** Signaux ******/
#define datapin 10   // pin 10 pour les données vers les registres à décallages
#define clockpin 11  // pin 11 pour l'horloge qui coordonne les registres à décallages
#define latchpin 8   // pin 8 pour le déclencheur des registres à décallages

/****** Boutons poussoir ******/
#define BoutonMinutes 12    // pin 12 pour le bouton poussoir d'incrément des minutes
#define BoutonHeures 13     // pin 13 pour le bouton poussoir d'incrément des heures
#define BoutonShift 7       // pin 7 pour le bouton poussoir shift
int EtatBoutonMinutes = 1;  // variable pour stocker l'état du bouton aprés sa lecture
int EtatBoutonHeures = 1;   // variable pour stocker l'état du bouton aprés sa lecture

/****** Alimentation des 7 segments en PWM ******/
#define ledPin 9                    // pin 9 pour le signal PWM de cadencement des afficheurs et leds
#define photodiodepin 0             // pin A0 pour la photodiode
unsigned int ValeurPhotoDiode = 0;  // variable pour stocker l'état de la photodiode aprés sa lecture

/****** Variables temporelles ******/
unsigned int heures;    // pour stocker les heures
unsigned int heuresINC; // pour stocker l'incrément des heures
unsigned int minutes;   // pour stocker les minutes
unsigned int minutesINC;// pour stocker l'incrément des minutes
unsigned int secondes;  // pour stocker les secondes
unsigned int annee;     // pour stocker l'annee
unsigned int mois;      // pour stocker le mois
unsigned int jour;      // pour stocker le jour
Chronodot HORLOGE;      // HORLOGE, nom choisis arbitrairement, référence à la librairie Chronodot

/****** Variables d'affichage ******/ 
int dizH = 0;          // pour stocker les dizaine des heures
int unitH = 0;         // pour stocker les unités des heures
int dizM = 0;          // pour stocker les dizaine des minutes
int unitM = 0;         // pour stocker les unités des minutes
byte AfficheurUN;      // données binaire pour l'afficheur UN, situé le plus à droite
byte AfficheurDEUX;    // données binaire pour l'afficheur DEUX
byte AfficheurTROIS;   // données binaire pour l'afficheur TROIS
byte AfficheurQUATRE;  // données binaire pour l'afficheur QUATRE, situé le plus à gauche
byte dataArray[10];    // Tableau de données

/*******************/
/* Initialisations */
/*******************/
void setup ()      // Fonction d'initialisation obligatoire
{
  dataArray[0] = B00000011;  // Case du tableau qui contient la valeur binaire pour afficher zero sur un afficheur 7 segments
  dataArray[1] = B10011111;  // Case du tableau qui contient la valeur binaire pour afficher un sur un afficheur 7 segments
  dataArray[2] = B00100101;  // Case du tableau qui contient la valeur binaire pour afficher deux sur un afficheur 7 segments
  dataArray[3] = B00001101;  // Case du tableau qui contient la valeur binaire pour afficher trois sur un afficheur 7 segments
  dataArray[4] = B10011001;  // Case du tableau qui contient la valeur binaire pour afficher quatre sur un afficheur 7 segments
  dataArray[5] = B01001001;  // Case du tableau qui contient la valeur binaire pour afficher cinq sur un afficheur 7 segments
  dataArray[6] = B01000001;  // Case du tableau qui contient la valeur binaire pour afficher six sur un afficheur 7 segments
  dataArray[7] = B00011111;  // Case du tableau qui contient la valeur binaire pour afficher sept sur un afficheur 7 segments
  dataArray[8] = B00000001;  // Case du tableau qui contient la valeur binaire pour afficher huit sur un afficheur 7 segments 
  dataArray[9] = B00001001;  // Case du tableau qui contient la valeur binaire pour afficher neuf sur un afficheur 7 segments 

  pinMode(clockpin, OUTPUT);     // pin correspondant à "clockpin" initialisée en sortie
  pinMode(datapin, OUTPUT);      // pin correspondant à "datakpin" initialisée en sortie
  pinMode(latchpin, OUTPUT);     // pin correspondant à "latchpin" initialisée en sortie
  pinMode(BoutonMinutes, INPUT); // pin correspondant à "BoutonMinutes" initialisée en entrée 
  pinMode(BoutonHeures, INPUT);  // pin correspondant à "BoutonHeures" initialisée en entrée     

  Wire.begin();     // initialisation du chronodot, référence à la librairie wire
  HORLOGE.begin();  // initialisation du chronodot, référence à la librairie Chronodot
      
//************ MISE à L'heure du module RTC DS3231 ************
  HORLOGE.adjust(DateTime(2014,12,25,10,30,12));  // années, mois, jour, heures, minutes, secondes
}

/*************/
/* Programme */
/*************/
void loop ()      // boucle du programme !
{
  horloge ();                // appelle la fct "horloge", récupération des données temporelles
  affiche ();                // appelle la fct "affiche", transfert des données temporelles sur les afficheurs 7 segments
  SurveilleBoutonHeures ();  // appelle la fct "SurveilleBoutonHeures", incrémente les heures si appuyé  
  SurveilleBoutonMinutes (); // appelle la fct "SurveilleBoutonMinutes", incrémente les minutes si appuyé  
  AjusteLuminosite();        // appelle la fct "AjusteLuminosite", plus il fait sombre, plus la lumière des afficheurs baisse
}

/***** Fonction d'horloge *******/   
void horloge ()
{
  DateTime now = HORLOGE.now();  // lecture de l'heure en cours dans la puce DS3231, référence à la librairie Chronodot
  heures = now.hour(), DEC;      // stocke l'heure en décimale dans la variable "heures" grace à la fct "hour" de la lib chronodot
  minutes = now.minute(), DEC;   // stocke les minutes en décimale dans la variable "minutes" grace à la fct "minute" de la lib chronodot
  secondes = now.second(), DEC;  // stocke les secondes en décimale dans la variable "secondes" grace à la fct "second" de la lib chronodot
  annee = now.year(), DEC;       // stocke l'année en décimale dans la variable "annee" grace à la fct "year" de la lib chronodot
  mois = now.month(), DEC;       // stocke le mois en décimale dans la variable "mois" grace à la fct "month" de la lib chronodot 
  jour = now.day(), DEC;         // stocke le jour en décimale dans la variable "jour" grace à la fct "day" de la lib chronodot
}

/***** Fonction d'affichage sur les 7 segments *******/  
void affiche ()
{
  dizH = heures / 10;   // par calcul, extrait la dizaine de "heures" et stocke le résultat dans "dizH" 
  unitH = heures % 10;  // par calcul, extrait l'unités de "heures" et stocke le résultat dans "unitH" 
  dizM = minutes / 10;  // par calcul, extrait la dizaine de "minutes" et stocke le résultat dans "dizM"   
  unitM = minutes % 10; // par calcul, extrait l'unité de "minutes" et stocke le résultat dans "dizM" 
        
  AfficheurUN = dataArray[unitM];    // stocke la valeur binaire 7 segments de l'unité de minutes dans "AfficheurUN"
  AfficheurDEUX = dataArray[dizM];   // stocke la valeur binaire 7 segments de la dizaine de minutes dans "AfficheurDEUX"
  AfficheurTROIS = dataArray[unitH]; // stocke la valeur binaire 7 segments de l'unité d'heures dans "AfficheurTROIS"
  AfficheurQUATRE = dataArray[dizH]; // stocke la valeur binaire 7 segments de la dizaine d'heures dans "AfficheurQUATRE"
  
  digitalWrite(latchpin, 1);                              // latch à l'état HAUT pour autoriser le transfert des données série   
  shiftOut(datapin, clockpin, LSBFIRST, AfficheurUN);     // envoi l'unités minute au registre à décallage
  shiftOut(datapin, clockpin, LSBFIRST, AfficheurDEUX);   // envoi la dizaine minute au registre à décallage
  shiftOut(datapin, clockpin, LSBFIRST, AfficheurTROIS);  // envoi l'unités heure au registre à décallage
  shiftOut(datapin, clockpin, LSBFIRST, AfficheurQUATRE); // envoi la dizaine heure au registre à décallage  
  digitalWrite(latchpin, 0);                              // latch à l'état BAS pour arreter le transfert des données série  
}

/***** Fonction Surveillance du BoutonHeures *******/        
void SurveilleBoutonHeures ()
{ 
  EtatBoutonHeures = digitalRead(BoutonHeures);  // Lit l'état du bouton (appuyé ou relaché) et stocke la valeur dans la variable "EtatBoutonHeures"
  if (EtatBoutonHeures == LOW)   // si le bouton est appuyé
    {  
    delay(170);                  // alors, attendre 170 ms, permet un appuie bref pour incrémenter de 1, et un appuie long pour incrémenter rapidement d'autant qu'on veut
    RegleHeures ();              // et appeller la fonction "RegleHeures"
    }  
}

/***** Fonction Surveillance du BoutonMinutes *******/        
void SurveilleBoutonMinutes ()
{ 
  EtatBoutonMinutes = digitalRead(BoutonMinutes);  // Lit l'état du bouton (appuyé ou relaché) et stocke la valeur dans la variable "EtatBoutonMinutes"
  if (EtatBoutonMinutes == LOW)    // si le bouton est appuyé
    {  
    delay(170);                    // alors,  attendre 170 ms, permet un appuie bref pour incrémenter de 1, et un appuie long pour incrémenter rapidement d'autant qu'on veut
    RegleMinutes ();               // et appeller la fonction "RegleMinutes"
    }  
}

/***** Fonction d'incrément Heures *******/ 
void RegleHeures ()
{ 
  heuresINC = heures + 1;  // additionne 1 à la valeur contenue dans la variable "heures" et stocke le résultat dans la variable "heuresINC"
  if (heuresINC > 23)      // si la valeur de "heuresINC" dépasse 23 (23h)
  {
    heuresINC = 0;         // alors, et la variable "heuresINC" à zero (minuit)
  }
    HORLOGE.adjust(DateTime(annee,mois,jour,heuresINC,minutes,0));  // récup des données temporelles depuis les différentes variables pour mise à l'heure la puce DS3231, secondes à zero
}

/***** Fonction d'incrément minutes *******/ 
void RegleMinutes ()
{ 
  minutesINC = minutes + 1;  // additionne 1 à la valeur contenue dans la variable "minutes" et stocke le résultat dans la variable "minutesINC"
  if (minutesINC > 59)      // si la valeur de "minutesINC" dépasse 59 (59min)
  {
    minutesINC = 0;         // alors, met la variable "minutesINC" à zero
  }
    HORLOGE.adjust(DateTime(annee,mois,jour,heures,minutesINC,0));  // récup des données temporelles depuis les différentes variables pour mise à l'heure la puce DS3231, secondes à zero
 }

 /***** Fonction d'ajustement automatique de la luminosité des afficheurs *******/ 
void AjusteLuminosite()
{
  ValeurPhotoDiode = analogRead(photodiodepin);  // Lit la valeur renvoyée par la photodiode, et stocke la valeur dans la variable "ValeurPhotoDiode"
  if (ValeurPhotoDiode > 500)       // si la valeur est supérieure à 500 (beaucoup de lumière reçue, genre en plein jour)
  {
     analogWrite(ledPin, 255);      // alors, illumination des afficheurs et leds à 100% (PWM de 0 à 255)
  }
  else if (ValeurPhotoDiode > 400)  // sinon, si la valeur est supérieure à 400
  {
    analogWrite(ledPin, 212);       // alors, illumination des afficheurs et leds moins forte    
  }
  else if (ValeurPhotoDiode > 300)  // sinon, si la valeur est supérieure à 300
  {
    analogWrite(ledPin, 169);       // alors, illumination des afficheurs et leds moins forte 
  }
  else if (ValeurPhotoDiode > 200)  // sinon, si la valeur est supérieure à 200
  {
    analogWrite(ledPin, 127);       // alors, illumination des afficheurs et leds moins forte 
  }
  else if (ValeurPhotoDiode > 100)  // sinon, si a valeur est supérieure à 100
  {
    analogWrite(ledPin, 83);        // alors, illumination des afficheurs et leds moins forte 
  }
  else                              // sinon,  (très peu voire pas du tout de lumière reçue, genre dans la nuit)
  {
    analogWrite(ledPin, 40);        // alors, illumination des afficheurs et leds aux minimum
  } 
}


À suivre


Ressources :

- http://pichonjulien.blogspot.fr/2009/11/pilotage-dun-afficheur-7-segments.html
- http://home.roboticlab.eu/fr/examples/display/segment_display
- http://www.sonelec-musique.com/electronique_theorie_afficheurs_led.html
- http://www.robot-maker.com/index.php?/tutorials/article/41-composant-les-afficheurs-7-segments/
- http://www.pobot.org/Piloter-des-afficheurs-7-segments.html
- http://playground2014.wordpress.com/arduino/1-3-7-segment-display/
- http://www.wikidebrouillard.org/index.php/Afficheur_7_segments_pilot%C3%A9_par_Arduino
- http://www.instructables.com/id/Different-methods-of-driving-7-Segment-LED-display/?ALLSTEPS
- http://www.sonelec-musique.com/electronique_realisations_afficheur_leds_7seg_007.html
- http://www.instructables.com/id/The-74HC164-Shift-Register-and-your-Arduino/?ALLSTEPS
- http://www.instructables.com/id/Multiplexing-with-Arduino-and-the-74HC595/?ALLSTEPS
- http://wiki.t-o-f.info/Arduino/ExempleD%C3%A9multiplexeurNum%C3%A9rique74HC595

- http://docs.macetech.com/doku.php/chronodot_v2.0
- http://schazamp.wordpress.com/2010/01/21/chronoblot/
- http://homecoder.wordpress.com/2013/12/12/getting-to-grips-with-a-real-time-clock/
- http://skyduino.wordpress.com/2012/01/07/tutoriel-arduino-horloge-rtc-ds1307-librairie-liquidcrystal/

- http://www.bricobidules.com/index.php?post/2012/04/29/iTime%2C-une-horloge-sous-Arduino-dans-un-bo%C3%AEtier-de-Mac-Mini
- http://www.instructables.com/id/Arduino-based-clock/
- http://kevinrye.net/electronics/source/

Commentaires

1. Le mercredi, 23 décembre 2015, 16:36 par gbdf1

Code tres bien commenter en etant neophyte jai tout compris. Une question je voudrais sur un afficheur different afficher les mois au format JAN. FEV.MAR. etc..
Partie electronique pas de soucis, partie code pas de souci mais ca recupere seulement des chiffres peut on modifier la librairie ou faire autre chose dans le code pour afficher les lettres

2. Le jeudi, 24 décembre 2015, 20:51 par Makoto

Sans aller si loin, fait simplement ça avec ton code.
Genre tu fais correspondre chaque chiffres au mois correspondants.

3. Le samedi, 26 décembre 2015, 16:03 par gbdf1

Dans le principe c est ce que j avais pensé. quand il doit ecrire 1 pour jan, le 2 pour fev etc... il le remplace mais pas assez competent pour l ecrite en code alors que je me doute que soit doit pas prendre plus de 2 ligne de code par mois, peut on m aider

4. Le mardi, 29 décembre 2015, 13:17 par gbdf1

bonjour comment sont cablé les condo 100nf sur les 74hc, je voit qu'il y en a 1 par 74hc? avais vous un plan a jour ainsi que le code avec le bouton shift?je suis entrain de realiser un montage avec 8 74hc en cascade

5. Le mardi, 29 décembre 2015, 17:48 par Makoto

Oh bien vu ! Merci ^^;
J'ai oublié de les mettre sur le schéma !
Je le mettrais donc à jour prochainement…
En attendant, il s'agit de condensateurs de découplage, donc connectés directement et au plus court aux pins d'alimentations (5V et Masse) des circuits intégrés.
Désolé, je ne pourrais pas aider pour le code, je ne suis pas assez performant pour répondre rapidement, et je n'ai pas trop le temps de me replonger dedans dans l'immédiat.

6. Le mardi, 5 janvier 2016, 18:30 par gbdf1

salut, ayant beaucoup ,de mal avec kicad pourrai tu m'envoyer ton fichier horloge.sch afin que je reparte sur de bonne base.
merci

7. Le mercredi, 6 janvier 2016, 22:21 par Makoto

J'ai joins le projet kicad complet à ce billet (Horloge.zip), car il me semble que j'avais édité et ajouté des composants à la librairie.

8. Le dimanche, 10 janvier 2016, 11:31 par gbdf1

merci pour le fichier supplementaire. lorsque je copie et colle ton code complet et que j'inclu la library chronodot jai malgré tout une erreur! y a t'il une autre librairie a inclure?

merci voici une copie de l'erreur surement pas grand chose!

In file included from C:\Users\aub\Documents\Arduino\sketch_jan10c\sketch_jan10c.ino:5:0:

C:\Users\aub\Documents\Arduino\libraries\Arduino-Chronodot-master/Chronodot.h:60:8: warning: extra tokens at end of #endif directive enabled by default

#endif CHRONODOT_H
       ^

In file included from C:\Users\aub\Documents\Arduino\libraries\Arduino-Chronodot-master\Chronodot.cpp:11:0:

C:\Users\aub\Documents\Arduino\libraries\Arduino-Chronodot-master\Chronodot.h:60:8: warning: extra tokens at end of #endif directive enabled by default

#endif CHRONODOT_H
       ^

In file included from C:\Program Files (x86)\Arduino\hardware\arduino\avr\cores\arduino/WString.h:29:0,

                from C:\Program Files (x86)\Arduino\hardware\arduino\avr\cores\arduino/Print.h:26,
                from C:\Program Files (x86)\Arduino\hardware\arduino\avr\cores\arduino/Stream.h:26,
                from C:\Program Files (x86)\Arduino\hardware\arduino\avr\libraries\Wire/Wire.h:26,
                from C:\Users\aub\Documents\Arduino\libraries\Arduino-Chronodot-master\Chronodot.cpp:9:

C:\Users\aub\Documents\Arduino\libraries\Arduino-Chronodot-master\Chronodot.cpp:26:31: error: variable 'daysInMonth' must be const in order to be put into read-only section by means of 'attribute((progmem))'

static uint8_t daysInMonth [] PROGMEM = { 31,28,31,30,31,30,31,31,30,31,30,31 };
                              ^

exit status 1
Erreur lors de la compilation.

9. Le dimanche, 10 janvier 2016, 15:07 par Makoto

Rien à ajouter, ça devrait marcher…
À savoir qu'il arrive que des compilations ne passent parfois plus une fois l'IDE Arduino mis à jour…
J'utilisais donc la version de juillet 2014 de l'IDE avec GNU/Linux.

10. Le dimanche, 28 mai 2017, 19:06 par Makoto

Plus précisément, ce code fonctionne correctement avec la version 1.5.5 de l'IDE Arduino
https://www.arduino.cc/en/Main/OldS...

Ajouter un commentaire

Les commentaires peuvent être formatés en utilisant une syntaxe wiki simplifiée.

Fil des commentaires de ce billet