LOGICATOR

PE6

BLOCKLY

 
La série d'articles qui suit, dans la présente rubrique PICAXE, a été écrite à partir de décembre 2013.
Il n'existait alors que peu de solutions abordables aux débutants pour programmer les PICAXES :
  • soit le BASIC,
  • soit LOGICATOR, programmation par logigramme, avec simulation.
Parallèlement  existait Picaxe Programming Editor qui était en phase d'abandon progressif au profit de LOGICATOR. 
A cette époque  LOGICATOR existait en version gratuite (mais aux fonctionnalités limitées), ou en version payante.
Enfin, bref, la programmation PICAXE cherchait sa voie.
 
En 2016, le monde PICAXE -- qui a bien progressé -- propose plusieurs solutions de programmation :
  • LOGICATOR, encore et toujours, mais il est désormais GRATUIT en version complète,
  • PICAXE EDITOR 6, gratuit,
  • BLOCKLY pour PICAXE, gratuit.
 
Lequel choisir ?
 
LOGICATOR
J'aime :
  • gratuit,
  • le programme BASIC est automatiquement généré à partir du logigramme ;
  • le logigramme offre une remarquable facilité de programmer les PICAXES, particulièrement pour des débutants ou des réfractaires à l'apprentissage d'un langage de programmation ;
  • la panoplie d'instructions est assez complète ;
  • le simulateur est très pratique.
 
J'aime moins :
  • le code BASIC est truffé de « label xx » et de « goto label xx », ce qui n'est pas une bonne programmation et ce qui occasionne des lenteurs dans l'exécution des programmes téléversés dans les PICAXES ;
  • de ce fait le code BASIC est difficile à suivre ;
  • un programme un peu important conduit à un logigramme volumineux, difficile à visualiser (et on dépasse très vite les limites de l'écran), donc pénible à mettre au point ;
  • logiciel sous WINDOWS uniquement.
 
Globalement cependant, j'aime beaucoup.
 
PICAXE EDITOR 6 (PE6)
J'aime :
  • intègre les trois modes de programmation en un seul logiciel : LOGICATOR, BASIC et BLOCKLY ;
  • passage instantané du mode « organigramme » ou du mode « blocs », vers le mode BASIC ;
  • possibilité de modifier le code BASIC généré par les deux autres modes : bien pratique pour bidouiller le code ;
  • simulateur très performant ;
  • très bonne qualité du code BASIC généré.
 
J'aime moins :
  • ... je cherche encore... Ah si ! Logiciel uniquement sous WINDOWS.
 
Petite précision pour clarifier les choses : les modes "BLOCKLY" et "LOGICATOR" savent générer du code BASIC, mais il n'est pas possible dans PE6 de générer l'un ou l'autre type d'organigramme à partir du BASIC.
Faut pas demander la Lune tout de même !
 
BLOCKLY pour PICAXE
J'aime :
  • passage instantané du mode BLOCKLY au code BASIC ;
  • possibilité de modifier le code BASIC généré (sans rétroaction sur l'organigramme "BLOCKLY" bien sûr) ;
  • simulateur très performant ;
  • mode « debug » efficace ;
  • très bonne qualité du code BASIC généré ;
  • possibilité d'écrire directement le code en BASIC.
 
... mais surtout :
  • graphisme excellent et très agréable ;
  • zoom et déplacement (glisser) de l'organigramme très faciles ;
  • possibilité de réduire ou développer les blocs individuellement ⇒ facilite énormément le travail sur les gros programmes ;
  • oblige à structurer correctement les programmes : utilisation des boucles, création de fonctions persos, etc. ;
  • manipulation et agencement des blocs très intuitifs ;
  • relecture extrêmement aisée des programmes : le contenu de chaque bloc (instruction) est affiché clairement et permet souvent de se passer des commentaires ;
  • possibilité de donner des noms « en clair » aux variables (par ex : « Code_IR » au lieu de « varA ») ;
  • possibilité de donner des noms « en clair » aux entrées/sorties (par ex : « LED Rouge » au lieu de « C.1 ») ;
  • possibilité de lier un commentaire à chaque fonction. Ces commentaires sont redimensionnables et mobiles, individuellement visibles ou masqués. Ils ressemblent à des info-bulles ou plutôt des phylactères. Sympa. Ces commentaires apparaissent aussi dans le code BASIC. Super !
  • on peut aussi ajouter des commentaires flottants (pour le titre du programme par exemple) ;
  • on peut choisir la langue (français, anglais...) ;
  • BLOCKLY peut fonctionner sur plusieurs plateformes : WINDOWS, LINUX, APPLE (voir ci-dessous).
 
J'aime moins :
  • il n'y a rien à jeter !
 
Lien vers le mode d'emploi de BLOCKLY pour PICAXE : http://www.picaxe.com/docs/picaxe_manual5.pdf
 
Lien vers une entrée de forum qui donne un complément d'informations :
http://www.picaxeforum.co.uk/showthread.php?28311-Programmation-par-Blocs-avec-Blockly-pour-PICAXE
 
À noter que BLOCKLY est intégré dans PE6 et donc que tout ce que j'aime dans BLOCKLY se trouve aussi dans PE6.
 
Mais ce n'est pas tout...
BLOCKLY peut être utilisé de 3 façons différentes :
  • ​intégré à PE6.
     
  • comme application autonome intégrée au navigateur Google CHROME ou CHROMIUM, et cela quel que soit le système d'exploitation (Linux, Windows, IOS Apple), avec ou sans sans connexion internet.
    De cette façon, BLOCKLY peut fonctionner sous UBUNTU par exemple.
     
  • directement sur le site www.picaxecloud.com, quel que soit le navigateur et quel que soit le système d'exploitation.
    On peut même l'utiliser sur tablette.
    (voir tout de même la Note1 ci-dessous). 
 
J'adore la deuxième façon, "application autonome intégrée au navigateur Google CHROME" :
  • le démarrage de BLOCKLY est très rapide ;
  • BLOCLY fonctionne sur n'importe quel système d'exploitation du moment qu'on dispose de CHROME ou CHROMIUM, et comme j'ai un faible pour UBUNTU... (Note2).
 
 
Si votre intention est d'utiliser exclusivement BLOCKLY (et éventuellement le BASIC) pour vos programmes, alors utilisez l'extension BLOCKLY intégrée à CHROME.
Si comme moi vous grenouillez aussi sur la planète ARDUINO, vous retrouverez les mêmes réflexes de programmation avec BLOCKLY for ARDUINO (BLOCKLY@rduino, BLOCKLYDUINO ou ARDUBLOCKLY).
 
 
Si vous voulez utiliser vos anciens programmes LOGICATOR, pour les mettre à jour, ou pour les ré-écrire en BLOCKLY, alors c'est PE6 qu'il vous faut.
 
 
Pour ma part, je ne renie pas LOGICATOR que je continuerai d'utiliser dans PE6, mais à présent mes nouveaux programmes seront écrits avec BLOCKLY.
 
 
 
 
________________________________________________
Note1 : 
9 mai 2016 : à l'heure où j'écris ces lignes je ne suis toujours pas parvenu à faire fonctionner BLOCKLY sur picaxecloud, quel que soit l'ordi (y compris la tablette et le smartphone), quel que soit le navigateur et quel que soit le système d'exploitation : la page ne se stabilise pas. On a l'impression qu'elle se recharge en permanence. J'ai envoyé un mail à A4 Technologies pour avoir une explication.
Si quelqu'un a la solution, contactez-moi : hubert.speri@gmail.com
 
Dans les mêmes conditions, BLOCKLY for ARDUINO fonctionne parfaitement bien en ligne.
Visiter ce lien : http://www.techmania.fr/BlocklyDuino/
A suivre.
 
29 mai 2016 : j'ai reçu une réponse étonnée de A4 Technologies qui prétend ne jamais avoir eu connaissance du problème !
Cependant le problème est bien réel.
Il ne dépend ni du système d'exploitation, ni de la machine (ordi, tablette, smartphone), ni du navigateur.
Il ne dépend pas non plus de ma box puisque j'ai aussi récemment constaté le problème en Croatie et à Frankfort avec les WiFi des hôtels et des aéroports. 
 
9 juin 2016 : la galère continue et même empire !
Après avoir, par hasard, réussi à stabiliser la page PICAXECLOUD, j'ai créé quelques petits programmes que j'ai enregistrés sur le cloud, comme le propose PICAXECLOUD.
Dans un premier temps j'ai même réussi à les recharger pour les modifier.
Depuis 15 jours, c'est la cata ! 
Quand j'ai enfin obtenu -- je ne sais toujours pas comment -- la stabilisation de la page et que je cherche à recharger un programme j'obtiens un message "You have no saved files to open", au lieu de la liste des programmes déjà enregistrés.
Mieux : je crée un nouveau programme, je l'enregistre et je cherche à le recharger => "You have no saved files to open" !
Ben voyons !
... autrement dit, j'ai perdu tous les programmes que j'ai créés en ligne avec PICAXECLOUD. Génial !
 
Un conseil : si vous voulez préserver vos nerfs et vos programmes, oubliez cette m... et utilisez PE6 ou l'application "Picaxe BLOCKLY" dans Chrome.
________________________________________________
Note2 :
Dans Apple iPad, la possibilité d'ajouter BLOCKLY comme application à CHROME semble ne pas exister.
 

08M2

Quelques notions de base

 
08M2 : le PICAXE INCONTOURNALE
(ce document fait suite au cours interne de formation du 05/08/2013)
Cette série d'articles est une création originale de Hubert SPERI,
adhérent de l'association BB1601.
 
Internet est plein de tutoriels sur le sujet.
Complets, souvent bien faits.

Mais quand on débute en programmation de ces petites merveilles, on aimerait bien avoir quelques repères simples pour éviter de trop patauger.
En voici quelques-uns :
 
«Philosophie» PICAXE :
Les PICAXES sont des micro-contrôleurs développés par REVOLUTION EDUCATION.
Ils sont pré-programmés ce qui leur confère des avantages décisifs pour tous les modélistes qui veulent développer des petites applications, sans passer leurs nuits à programmer en assembleur :
  • programmation en BASIC,
  • programmation graphique avec LOGICATOR,
     
  • programmation "in situ", c'est à dire qu'il n'y a pas besoin d'une carte externe pour la programmation : le PICAXE est dès le départ installé sur le PCB du montage électronique et, sans le démonter, sans modifier quoi que ce soit sur le PCB (même pas un strap), on "injecte" le programme grâce à une connexion USB/Jack 3.5 aussi souvent que nécessaire,
     
  • pas besoin de s'inquiéter du code qui paramètre la fréquence d'horloge (comme sur les PIC12Fxxx par exemple),
  • accès à des fonctionnalités originales :
 
- émission et réception des commandes infrarouges codées à la norme SONY,
- mesure et calibration d'impulsions,
- commande de moteurs et de servo-moteurs,
- émission et réception ultrason.
La programmation "in situ" est un avantage incommensurable.
La mise au point ou la retouche des programmes en est grandement facilitée.
 
 
Mise à jour du 9 juin 2016 :
Depuis que j'ai écrit cet article, la "planète PICAXE" a évolué.
Il y avait LOGICATOR et BASIC.
Il y a maintenant PICAXE EDITOR 6 (PE6) et BLOCKLY.
Pour en savoir plus, c'est en haut de cette page.
 
Brochage du 08M2 :
  • 8 broches
    Numérotées de 1 à 8 en tournant dans le sens inverse des aiguilles d'une montre (en vue de dessus).
  • Broche 1 = + 5 Volts
  • Broche 8 = masse
 
Entrées / sorties :
Les 6 autres broches sont numérotées de C0 à C5, cette fois dans le sens des aiguilles d'une montre.
  • C0 (broche 7) = sortie 0
  • ...
  • C5 (broche 2) = entrée série.
     
Le PICAXE 08M2 peut être paramétré de façon à fournir 2 ou 3 ou 4 ou 5 entrées assorties à 4 ou 3 ou 2 ou 1 sorties (le total faisant toujours 6).
 
 
Sortie C0 (broche 7) :
  • C0 est obligatoirement une sortie,
  • C0 peut être une sortie LOGIQUE (1 ou 0)
  • ... ou une sortie série, suivant son paramétrage.
  • C0 (et elle seule) est utilisée pour la sortie infrarouge (émission des codes infrarouges 38 kHz conformes à la norme SONY-TV).
  • C0 est employée comme sortie de contrôle lors de la programmation du PICAXE.
    En conséquence la résistance connectée à cette sortie (pour alimenter une LED par exemple) ne devra pas être inférieure à 330 Ohms, sinon on risque de bloquer l'injection du programme dans le 08M2.
 
 
Entrée C5 (broche 2) :
  • C5 est obligatoirement une entrée. (voir Note)
  • Cette entrée peut être numérique (1 ou 0)
  • ... ou une entrée série (utilisation en transmission de datas).
  • C5 est utilisée pour injecter les programmes dans le PICAXE, à travers le pont 22k/10k.
    Attention donc à ne pas gêner cette entrée avec un contact fermé ou une autre résistance d'entrée.
 
Note : attention, l'utilisation de C5 est délicate. En effet, son utilisation nécessite une astuce de programmation sinon on peut bloquer le PICAXE en reprogrammation et obliger à une manipulation de ré-initialisation.
 
Entrée C3 (broche 5) :
  • C3 est obligatoirement une entrée.
  • Cette entrée peut être numérique (1 ou 0)
  • C3 peut être utilisée comme entrée analogique (pour tester une tension d'entrée par exemple).
  • C3 (et elle seule) est utilisée pour traiter les codes infrarouges émis par une télécommande au standard SONY.
 

C0, C1, C2 et C4 (ou C.0, C.1, C.2 et C.4) :

Ce sont les 4 seules sorties possibles.
Nous avons déjà parlé de C0.
Les trois autres (C1,C2 et C4) peuvent être paramétrées comme entrées ou comme sorties, comme l'indique le diagramme en début de la page.
 
Bien entendu ces entrées/sorties ont d'autres propriétés qu'il est trop tôt de détailler ici.
 
 
Capacité des sorties C0 à C4 :
 
Après vérifications, le constructeur recommande de ne pas dépasser un courant 20mA par sortie.
Ceci implique que, pour alimenter une LED par exemple, la résistance minimale de limitation est de 120 à 150 Ohms.
Il est plus prudent de se tenir à des valeurs supérieures à 220 Ohms.
Ce faible courant de sortie implique aussi qu'on ne pourra pas alimenter un moteur électrique directement sur une sortie de PICAXE.
 
 
 
Autres performances des sorties du 08M2 :
La sortie C2 (broche 5) peut être pilotée pour délivrer un signal PWM (Pulse Wide Modulation).
En français : MLI = Modulation de Largeur d'impulsion.
 
Intérêts d'une telle possibilité :
  • Moduler la luminosité d'une LED en faisant varier le rapport cyclique du signal,
  • Commander efficacement les ralentis de moteurs à courant continus,
  • Cette instruction ne bloque pas le déroulement de la suite du programme : tant qu'on ne la modifie pas elle se déroule de façon autonome en tâche de fond, au même titre qu'une sortie activée reste active tant qu'on ne la désactive pas.
 

Matériel

et

logiciel de base

 
 
Pour débuter on a besoin de quatre choses :
  • le circuit didactique AXE092
  • LOGICATOR dans sa version libre
  • le cordon de programmation AXE027
  • 3 piles 1,5 Volts...
    ... et l'envie de réussir
 
AXE092 :
 
 
Ce petit circuit propose :
  • 2 entrées commutables (C3 et C4)
  • 3 sorties (CO,C1 et C2) dont 2 sont commutables
  • 1 capteur LDR de lumière en entrée sur C4
  • 1 bouton poussoir en entrée sur C3
  • 1 buzzer piezzo en sortie sur C2
  • 3 LED's sur C0 (rouge), C1 (jaune) et C2 (verte).
 
 
... de quoi s'amuser un peu !
 
 
 
LOGICATOR :
 
C'est un logiciel de programmation graphique.
On dessine l'organigramme du programme.
Cet organigramme va directement générer le code de programme qui sera injecté dans le PICAXE.
 
Dans la version de base de LOGICATOR, seules quelques fonctions sont accessibles.
Elle sont suffisantes pour se faire la main et "écrire" (on devrait dire "dessiner") les premiers programmes.
 
Avant toutes choses :
Il faut déclarer le type de PICAXE qu'on utilise, ainsi que sa configuration entrées/sorties.
Le menu Options / Sélectionner le type de PIC... ouvre la boite de dialogue ci-dessous :
 
Choisir PICAXE08M ou PICAXE 08M2
Choisir 3 entrées - 3 sorties (0, 1, 2) et valider
 
Remarque : avant chaque programme il faudra vérifier qu'on a bien le réglage qui correspond au PICAXE employé et à sa configuration d'entrées/sorties.
 
Construire un organigramme :
Quel que soit le langage de programmation utilisé (LOGICATOR, BASIC, ASSEMBLEUR, "C", PASCAL, etc.) un programme doit d'abord être analysé et établi sous forme d'un organigramme logique.
C'est INDISPENSABLE.
La bonne idée de LOGICATOR c'est précisément que cet organigramme dessiné génère le vrai code du programme ! Génial non ?
 
L'écran d'accueil de LOGICATOR propose un diagramme vide, avec seulement "DEBUT" qui marque le point de départ du futur programme.
 
Pour construire l'organigramme :
Sélectionner le type de PIC... (voir ci-dessus).

Permet d’ouvrir la configuration du PICAXE.
Mode sélection.
Choisir la fonction désirée, en bleu dans la colonne de droite, et la déplacer en maintenant le bouton gauche de la souris enfoncé jusque dans une cellule.
Mode tracé de liaison.
Une fois les fonctions mises en places et paramétrées, ce mode permet de dessiner des liaisons pour relier les blocs.
Cliquer avec le bouton gauche sur le premier bloc puis cliquer sur le dernier bloc pour
établir la liaison.
Programmer le PIC.
Permet de télécharger le programme dans le micro-contrôleur PICAXE.
La programmation sera injecté uniquement si la liaison est correcte (câble USB installé, micro-contrôleur PICAXE sélectionné et alimenté).
Un seul programme par PICAXE.
Bien entendu la barre d'outils propose d'autres fonctions mais les quatre ci-dessus constituent la base de l'élaboration et de l'injection d'un programme dans le PICAXE.
 

Premier

programme

 
SOn se propose de programmer la séquence suivante :
  • allumer la LED rouge pendant 4 secondes,
  • éeindre la LED rouge et allumer la jaune pendant 2 secondes,
  • éteindre la LED jaune et allumer la LED verte pendant 5 secondes,
  • boucler indéfiniment.
 
Cette séquence pourrait correspondre, en plus rapide, à la séquence d'allumage des feux de carrefour (une des deux directions seulement).
 
Inventaire des sorties nécessaires :
En sortie le montage doit piloter 3 LED's.
On a donc besoin de 3 sorties.
Un PICAXE 08 ou 08M ou 08M2 est suffisant.
 
 
 
Représentation chronologique des séquences : premier organigramme
 
Ne pas négliger ce petit exercice graphique.
Il permet de mieux visualiser le déroulement du programme.

 
Il fait apparaître 9 actions dans la séquence : x3 activations ; x3 désactivations ; x3 temporisations.
L'organigramme du programme sera donc composé de 9 blocs de fonctions.
 
Version "BLOCKLY for PICAXE",
application intégrée à Google Chrome
   
Avouez que c'est sympa et plus élégant...
 
 
 
Deuxième organigramme :
Cette fois-ci, au lieu d'utiliser les instructions "Activer" et "Désactiver", on utilise l'instruction "Sorties" qui permet de traiter les 3 sorties en une seule fois.
On obtient un organigramme plus compacte et plus élégant.

 
 
 
Chaque fonction "Sorties" regroupe les états des 3 sorties, rouge, jaune et verte, càd C0, C1 et C2.
 
N.B. les "bulles" jaunes ne sont là que pour documenter le programme.
 
Variations sur un même thême :
 
En modifiant simplement les durées des temporisations, ce programme peut être utilisé pour d'autres applications.
  • si par exemple on règle les trois "Attentes" à 0,2 secondes, on peut constituer un gyrophare à trois LED's 0402 très réaliste ;
  • avec des valeurs de 10 à 60 secondes on peut obtenir un éclairage intérieur de bâtiment dans lequel 3 pièces s'éclairent successivement.
    C'est sommaire mais ça fonctionne.
 

Tester

un

niveau logique

 
 
Séquence à programmer :
  • Au repos, la LED verte est allumée.
  • On appuie sur le petit poussoir (circuit didactique AXE092) => la LED jaune clignote et la verte s'éteint.
  • On relâche le poussoir => la LED jaune s'éteint et la verte se rallume.
 
 
Inventaire des entrées / sorties nécessaires :
En sortie le montage doit piloter 2 LED's.
On a donc besoin de 2 sorties. On choisira C1 et C2
Penser à sélectionner le type de PICAXE : 08, 08M ou 08M2.
N.B. le circuit didactique a toujours trois sorties (C0, C1 et C2)
 
Le poussoir est câblé sur l'entrée C3
 
ORGANIGRAMME :
 
 
Le programme comporte DEUX boucles :
  • la boucle qui active en permanence la sortie 2 (C2) quand le poussoir est relâché,
  • la boucle qui fait clignoter la LED jaune sur la sortie 1 (C1) tant qu'on reste appuyé sur le poussoir.
 
Il peut paraître curieux de répéter en permanence l'ordre d'activer C2. quand on n'actionne pas le poussoir.
En fait on n'a pas d'autre choix : on doit pouvoir tester à tout moment l'état du poussoir : appuyé ou relâché.
 
Il est donc indispensable de parcourir l'instruction de test au cours de l'une ou l'autre boucle.
 
 
Ci-dessous, deux versions de ce même programme avec GOOGLE BLOCKLY

(avec en prime, les programmes BASIC correspondants, dans les commentaires).
BLOCKLY_SPIROU_BoutonPoussoir_1.png
BLOCKLY_SPIROU_BoutonPoussoir_2.png
 

Tester

une

LDR

Utiliser une LDR (photo-résistance) comme capteur d'entrée d'un PICAXE ?
 
Il y a deux possibilités :
  • soit on utilise la LDR en tout ou rien : éclairée à fond ou occultée.
  • soit on teste le niveau de luminosité qu'elle reçoit.
 
 
MATÉRIEL :
Le circuit didactique AXE092 est équipé d'une LDR sur l'entrée C4 (broche 3 du 08M2).
En fait il s'agit d'un pont constitué de la LDR et de la résistance de 10k.
 
 
NOUVELLES FONCTIONS :
 
[C.A.N.], Conversion Analogique Numérique.
 
On la trouve dans le volet [Autres E/S].
Cette fonction n'est applicable que sur les entrées C1, C2 et C4.
Elle permet de convertir une tension comprise entre 0 et 5 volts en une valeur numérique comprise entre 0 et 255.
 
 
[Comparer] :
 
On la trouve dans le volet [Autres E/S].
Cette fonction n'est applicable que sur les entrées C1, C2 et C4.
Elle permet de convertir une tension comprise entre 0 et 5 volts en une valeur numérique comprise entre 0 et 255.
 
 
PREMIER PROGRAMME :
 
D'après les caractéristiques des PICAXES :
  • Une tension d’entrée supérieure à 4 V, càd (0,8 x V+) constitue un niveau haut.
  • Une tension d’entrée inférieure à 0,1 V, càd (0,2 x V+) constitue un niveau bas.
 
Lorsque la LDR est fortement éclairée sa résistance descend en dessous de 2 kOhms et la tension sur C4 est supérieure à 4 Volts => C4 est au niveau haut.
Lorsque la LDR ne reçoit pas de lumière sa résistance est très élevée et la tension sur C4 est
inférieure à 0,1 V => C4 est au niveau bas.
 
Un exemple, directement dérivé du programme de test d'un niveau logique est donné ci-dessous :
TEST_LDR_1.png
<<< CLIC pour agrandir l'image.
Bien que le capteur d'entrée soit une résistance variable, et pas un contact, l'entrée C4 est testée comme une entrée logique.
 
Cette méthode n'est pas très académique mais elle fonctionne parfaitement bien.
 
 
 
DEUXIÈME PROGRAMME :
LDR_1.png
 
 
Suivant le niveau d'éclairement, la résistance d'une LDR varie d'environ une centaine d'Ohms en pleine lumière à plus de 1mégohm dans l'obscurité.
 
Toutes les valeurs intermédiaires sont possibles et c'est ce que le programme suivant se propose de tester.
TEST_LDR_2.png
 
 
On utilise l'instruction C.A.N. (Conversion Analogique Numérique) que l'on trouve dans 
"Autres entrées/sorties".
On paramètre cette fonction comme indiqué dans la boite de dialogue :
  • lecture de la tension sur l'entrée 4 (entrée C4)
  • stockage de la valeur de cette tension dans la variable A.
 
La tension analogique sur C4 sera comprise entre 0 et 5 Volts (ou 4,5 Volts suivant la tension d'alimentation).
 
La variable "A" stocke une valeur entière comprise entre 0 et 255 :
  • tension sur C4 = 0 => A = 0
  • tension sur C4 = 5 Volts => A = 255
 
Le test est réalisé par la fonction [Comparer] que l'on trouve dans "Variables".
COMPARER.png
 
Les trois zones de saisie dans "Configurer l'expression de comparaison" permettent d'écrire l'expression mathématique employée pour le test.
 
Dans le cas présent l'expression signifie :
 
[si A est plus grand que 127 (càd 2,5 Volts sur l'entrée C4) alors je fais ceci, sinon je fais cela]
Cette fonction de comparaison est d'une très grande richesse.
 
Par la suite nous verrons d'autres utilisations plus élaborées.
Le GRAND intérêt de cette méthode, par rapport à celle du premier programme, réside dans la possibilité de décider à partir de quelle valeur d'éclairement on bascule sur l'une ou l'autre action.
 
Si on utilise cette fonction pour réaliser un interrupteur crépusculaire on pourra ainsi ajuster le seuil lumineux à partir duquel on décide d'enclencher l'allumage des réverbères ou des bâtiments de notre réseau miniature, par exemple.
 

Flash

Clignotant

Atténuation

 
 
CLIGNOTANTS, FLASHS, ATTENUATIONS etc.
 
Et si tout ça c'était la même chose ?
 
 
 
Remarque : on utilise toujours le circuit didactique AXE092
 
 
CLIGNOTANT
La LED s'allume et s'éteint sur un cycle de 0,5 à 2 secondes (par exemple).
Les phases d'extinctions et les phases d'allumages ont des durées analogues.
 
 
FLASH
La LED produit un éclat très court puis reste éteinte pour une durée qui dépend de l'utilisation :
  • flash d'appareil photo : 1 éclat toutes les 30 secondes, par exemple.
  • flash de police : 1 éclat toutes les secondes.
  • flash de feux de chantiers : éclats en cascade, espacés d'environ 0,3 à 0,5 secondes.
  • etc.
 
ATTÉNUATION
Le sujet a déjà été évoqué plus haut.
La séquence ressemble étrangement à celle du flash.
 
Il s'agit d'un clignotement très rapide.
L'œil ne distingue plus les phases "allumées/éteintes", mais seulement un niveau moyen de luminosité.
 
Si on fait varier le rapport "allumé/éteint" de 1ms/10ms à 10ms/1ms, l'éclat de la LED varie d'environ 10% à environ 90%.
 
 
... ET LES PROGRAMMES, ILS RESSEMBLENT À QUOI ?
 
 
Les différents effets sont obtenus en modifiant les temporisations ( [Attendre xxx] )
 
Version BLOCKLY  (ajoutée le 7 mai 2016)
 
Essayez et amusez-vous bien !
Petit supplément : (ajouté le 8 mai 2016)
L'image ci-dessous donne 3 versions de la même séquence élémentaire, conduisant à 3 comportements différents de la LED connectée sur la sortie C.1.
Seules changent les valeurs des temporisations.
 
Les deux blocs ci-dessous montrent une autre façon d'écrire la séquence de clignotement
et la séquence de flash.
 
C'est assez élégant.
 
 

Flash

de pénétration

(police)

 
Ce programme est dédié à José, pour apaiser ses craintes et lui montrer qu'un programme complexe n'est qu'un assemblage de morceaux simples.
 
Fini de faire mumuse  !
Au boulot les PICAXIENS !
Voici votre premier programme évolué.
... juste un peu mais il faut bien commencer un jour.
 
 
MATÉRIEL UTILISÉ
Le circuit didactique AXE092 servira de base de travail, cette fois encore.
 
Ah ! j'oublie tout le temps : pensez à basculer les switchs bleus sur ON.
 
 
NOUVELLES FONCTIONS
 
[Procédure] et [Retour] :
On les trouve dans le volet [Procédures].
 
Ce tandem est indissociable. Il permet d'écrire des morceaux de programmes qui sont autant de nouvelles fonctions personnelles.
Grâce aux procédures la structure des programmes sera allégée et surtout beaucoup plus compréhensible.
PROCEDURE_1.png
[Appeler procédure] :
... toujours dans le volet [Procédures].
 
Ne surtout pas confondre avec [Aller à procédure].
Lorsque l'exécution de la procédure est terminée, le retour au programme principal s'effectue juste derrière l'instruction
 [Appeler procédure].
PROCEDURE_2.png
 
 
 
PROGRAMME
 
But du programme
Nous voulons simuler les flashs dits "de pénétration" d'un véhicule de police :
  • trois flash à gauche
  • un temps d'attente
  • trois flash à droite
  • un temps d'attente
  • ... et bouclage
 
Le montage définitif fonctionnera avec deux LED's bleues ou blanches.
Cependant, pour la mise au point du présent programme on utilisera le circuit AXE092, sur  les sorties C1 et C2 (LED jaune et LED verte).
 
 
Séquence de flash
  • la LED de gauche flashe 3 fois de suite suivant cette séquence.
 
  • ensuite on attend 300 milli-secondes et c'est la LED de droite qui flashe 3 fois.
Traduction dans LOGICATOR d'un simple flash (un seul éclat) :
 
... et d'une séquence de trois flashs :
Et voici le programme complet :
 
Oh ! que j'ai honte !
Beaucoup d'instructions pour pas grand chose.
Le moins qu'on puisse dire c'est que ce programme n'est pas très élégant.
Mais il est intéressant tout de même.
On remarque en effet que chaque séquence de clignotement est répétée TROIS FOIS.
 
Alors, si on s'arrangeait pour n'écrire que UNE SEULE FOIS chacune des deux séquences ?
 
Allons-y...
 
 
VERSION DU PROGRAMME AVEC PROCÉDURES
 
Construction du programme
 
 
Procédure pour UN éclat de flash
  • on écrit la séquence élémentaire de clignotement.
  • ensuite on l'encadre par [Procédure] et [Retour] que l'on trouve dans la liste des fonctions, dans la rubrique "Procédures". (voir ci-contre >>> )
  • enfin on donne un nom à cette procédure :
 
 
<<< De la même façon on écrit la procédure pour le flash de droite.
Haut les cœurs !
Vous venez d'écrire vos deux premières fonctions perso !
Reste à les réunir et à les faire fonctionner.
 
 
Programme principal
Il va se contenter, dans ce cas simplissime, d'appeler trois fois chacune des 2 séquences élémentaires de flash et de régler l'espacement de ces salves à 300 milli-secondes.
 
 
Admirez le travail !
 
 
C'est pas beau tout ça ?
 
Fonctionnement du programme principal :
  • Appel du sous-programme FLASH_GAUCHE, parcouru 3 fois,
  • Attente 300 ms,
  • Appel du sous-programme FLASH_DROIT, parcouru 3 fois,
  • Attente 300 ms,
  • Bouclage.
 
Plus simple on peut pas.
 
Et surtout : en cas de modifications des temporisations on n'a pas à modifier les valeurs dans 12 endroits différents (ou plus) !
 
N.B. la boîte de dialogue montre que c'est la variable H qui stocke le nombre d'itérations du sous-programme, avant d'en ressortir.
 
 
Version BLOCKLY
 
 
Dans le programme BLOCKLY ci-dessous, c'est la variable "varA" qui est proposée à la place de "H".
Ne pas changer cette variable, sauf nécessité absolue.
 
 
Variante
Ah ! En plus vous aimeriez que les feux de pénétration soient déclenchés par le bouton poussoir ?
Ce n'est pas un problème.
 
Sur le circuit AXE027 le bouton poussoir est connecté à l'entrée C3 du PICAXE 08M2 :
 
 
Voici le programme :
 
 
Tant que le bouton poussoir est relâché le programme boucle sur l'instruction [Décision] "Poussoir enfoncé", et le programme n'est donc pas exécuté ⇒ pas de flashs.
Tant que le bouton poussoir est enfoncé le programme se déroule.
A chaque fin de cycle le bouton poussoir est de nouveau testé : si le poussoir est relâché, les flashs s'arrêtent.
 
N.B. ce programme ne mémorise pas la position du poussoir.
 
 
Version BLOCKLY
 
 
Remarque
Il est intéressant d'observer la structure des deux programmes BLOCKLY ci-dessus :
Sur le deuxième on voit nettement que la partie "Flashs" est entièrement contenue dans la fonction "Si..." en bleu, et donc fonctionne à l'intérieur de cette fonction de test.
C'est beaucoup moins évident sur l'organigramme LOGICATOR.
BLOCKLY offre une bien meilleure lisibilité de la logique des programmes.
Quelqu'un a dit "... et si on mémorisait la position du poussoir ?". Si, si, j'ai entendu.
C'est comme si c'était fait...
 

Mémoriser

l'appui

sur un contact

 
 
BUT DE L'EXERCICE
Nous allons cette fois nous arranger pour que l'appui sur le contact soit mémorisé :
  • appui sur le poussoir,
  • relâchement du poussoir => mise en route du programme,
  • déroulement du programme sans intervention sur le poussoir,
  • nouvel appui sur le poussoir pendant environ 1 seconde => le cycle du programme s'arrête,
  • relâchement du poussoir => retour à l'état de départ.
 
MATÉRIEL
Cette fois encore nous utilisons le circuit didactique AXE092 :

Le poussoir est sur l'entrée C3 du PICAXE 08M2.
 
SÉQUENCE POUR MÉMORISER L'APPUI SUR UN POUSSOIR
 
Pour cet exercice on part du programme programme précédent pour le FLASH de PENETRATION et on le modifie.
Avez-vous remarqué que, dans les applications que vous utilisez sur votre PC, le clic gauche de la souris ne déclenche l'action choisie que lorsqu'on relâche le bouton ?
 
Nous allons fonctionner de la même façon.
Ceci présente plusieurs avantages :
  • on maîtrise mieux les temps d'appui sur le poussoir,
  • les rebonds de contact n'ont plus d'effet indésirable,
  • le fonctionnement est sûr.
 
La séquence ci-dessous montre le fonctionnement du test du poussoir au démarrage du programme :
  • tant que le poussoir est relâché on boucle sur la première instruction de test,
  • si on appuie sur le poussoir (branche "Oui") on passe à la deuxième fonction de test, et on boucle sur cette instruction tant qu'on reste appuyé sur le poussoir,
  • lorsqu'on relâche enfin le poussoir (branche "Non"), le programme démarre.
 
 
 
La deuxième séquence montre le fonctionnement du test du poussoir pour quitter le programme :
 
La séquence de test est INCLUSE à la fin de la boucle du programme principal.
 
  • tant que le poussoir est relâché (branche "Non", fonction test de droite) on re-boucle sur le programme,
  • si on appuie sur le poussoir (branche "Oui") on quitte le cycle et on passe à la deuxième fonction de test (celle de gauche),
  • on boucle sur cette instruction tant qu'on reste appuyé sur le poussoir,
  • lorsqu'on relâche enfin le poussoir (branche "Non"), on retourne au DEBUT de l'organigramme.
 
REMARQUE IMPORTANTE : en utilisant deux fonctions de test en cascade, telles que ci-dessus, on s'aperçoit qu'un temps d'appui long ou très long sur le poussoir n'a pas d'effet indésirable.
 
N.B. Attention ! la deuxième séquence de test du poussoir ne sera prise en compte qu'à la fin de chaque boucle du programme principal.
Cela signifie que pour arrêter le déroulement du programme il faudra appuyer sur le poussoir jusqu'à la fin de l'exécution de la boucle en cours.
Dans le cas ci-dessus ce temps est au pire d'environ 600 milli-secondes.
 
 
PROGRAMME COMPLET
 
 
Version BLOCKLY
 
 
 
... et la décomposition de la séquence principale qui montre la structure des boucles anti-rebond :
 

Multi-tâches

Notions

 
 
Le PICAXE 08M2 permet de "faire tourner" jusqu'à 4 programmes simultanément.
Ces quatre programmes sont appelées «tâches».
 
 
 
 
Matériel
Circuit didactique AXE092
 
Nouvelle fonctionnalité
Les séries M2 et X2 des PICAXES permettent de faire "tourner" simultanément jusqu'à 4 programmes différents, appelés "tâches". (D'où l'appellation "multi-tâches").
 
La balise [Début] est dans le volet [Général].
(LOGICATOR)
MULTI_TACHE_1.png
 
 
 
Simples exercices
Premier exercice
 
  • la LED sur la sortie C1 clignote au rythme de 0,5s / 0,5 s,
  • la LED sur la sortie C2 émet un flash toutes les 5 secondes.
 
Facile !
 
On peut exprimer ce qui précède en disant : la LED sur C2 émet un flash tout les 5 cycles de la LED sur C1.
 
Voici le programme avec deux procédures :
 
 
 
  • le programme principal appelle la procédure [CLIGNOTE] qui est parcourue 5 fois,
  • a la fin du cinquième clignotement le programme appelle la procédure [FLASH]
 
Analyse :
 
Oui, cela fonctionne conformément au problème posé, mais...
... mais les deux séquences [CLIGNOTE] et [FLASH] ne sont pas indépendantes.
Elles sont même parfaitement synchronisées : il faut attendre la fin de l'une pour que l'autre démarre.
Si on désire des clignotements avec des cadences différentes on risque de ne pas y arriver facilement (voir pas du tout) avec cette méthode.
 
 
 
 
Deuxième exercice
 
  • la LED sur la sortie C1 clignote au rythme de 2 s / 2 s,
  • la LED sur la sortie C2 émet un flash toutes les 4,2 secondes.
 
Ah ! cette fois le problème n'est pas si simple.
Impossible avec le programme ci-dessus d'inclure le coup de flash une fois toutes les 4,2s à l'intérieur du cycle de clignotement de 4 secondes.
 
On va créer DEUX TÂCHES – c'est à dire 2 programmes – qui vont fonctionner simultanément :
 
Cette fois on a bien deux cycles indépendants.
On constate que le cycle du flash se décale lentement par rapport au cycle du clignotement.
 
N.B. les valeurs 2 s + 2 s pour le cycle de clignotement sont intentionnelles : elles permettent de constater facilement ce décalage de 200 ms supplémentaires à chaque cycle.
Si maintenant vous décidez d'utiliser des valeurs de 0,5 + 0,5 secondes la non-synchronisation sera moins facile à observer mais tout aussi réelle.
 
Versions BLOCKLY
 
 
La fonction [Attendre], dans LOGICATOR, permet de paramétrer des durées de temporisations jusqu'à 60 secondes maxi.
« – Oui, mais moi je voudrais que l'intérieur de ma rotonde reste éclairé 24 minutes.
Je ne vais tout de même pas empiler 24 fonctions [Attendre] de 60 secondes chacune ! 
 – Meuh non, voyons !
On va se la construire avec élégance cette tempo. »
 
 
 
 
Matériel
Circuit didactique AXE092

Temporisations

longues

 
 
 
Principe
Puisque la durée maximale est de 60 secondes, nous allons construire la petite procédure très très simple ci-contre :
On lui donne le nom "TEMPO_60"
On règle le temps de la fonction [Attendre] à 60 secondes,
càd 1 minute.
Il suffit ensuite d'appeler la procédure TEMPO_60 et de la parcourir autant de fois que le délai requis compte de "minutes".
 
 
EXEMPLE DE PROGRAMME :
 
Cahier des charges rapide :
  • débuter la séquence d'éclairage "sur commande" grâce au poussoir sur l'entrée C3, avec mémorisation ;
  • éclairer la LED sur la sortie C1 pendant 7 minutes ;
  • éclairer la LED sur la sortie C2 pendant 22 minutes ;
  • on veut aussi un recouvrement des périodes de façon que C1 et C2 soient actives ensemble pendant 2 minutes ;
  • arrêt automatique en fin de séquence (pas de bouclage).
 
 
Diagramme :
 
Il fait apparaître 3 phases :
  • C1 active pendant 5 minutes, seule ;
  • C1 et C2 actives ensemble pendant 2 minutes ;
  • C2 active pendant 20 minutes, seule.
 
 
 
Organigramme LOGICATOR :
Programme_test_TEMPO_LONGUE_1.png
 
Chacune des phases d'éclairage appelle la procédure TEMPO_60.
La première parcourt 5 fois la procédure pour une tempo de 5 minutes.
 
 
A la fin de la troisième phase, ce programme ne boucle pas sur lui-même. Il s'arrête tout simplement.
 
Pour le relancer il faut couper et remettre l'alimentation 5 Volts.
Si on veut pouvoir relancer le programme avec le poussoir, il suffit de remplacer l'instruction [Fin] par un bouclage sur [Debut].
 
Remarque... intéressante :
 
Pour vérifier que le programme fonctionne correctement et en totalité il faut s'armer de patience : 
27 minutes !!!
Grâce à la procédure TEMPO_60 on va pouvoir voyager très vite dans le temps.
 
Pour cela il suffit de changer la valeur du temps élémentaire dans la fonction [Attendre].
On le ramène provisoirement à 1 seconde, au lieu de 60.
Les trois phases dureront alors respectivement 5 secondes, 2 secondes et 20 secondes.
 
 
Sympa, non ?
On change UN SEUL PARAMETRE et les trois temporisations du programme sont réduites d'un seul coup dans la même proportion !
 
 
J'adore...
Version BLOCKLY ajoutée le 7 mai 2016 :
 

Interrupteur

crépusculaire

 
Petit retour sur l'usage d'une LDR (photorésistance).
 
 
Le chapitre ci-dessus «Tester une LDR» montre l'utilisation d'une LDR pour tester un seuil de luminosité.
Le présent chapitre propose deux exemples de programmes :
  • interrupteur crépusculaire à UN SEUIL, avec HYSTERESIS,
  • interrupteur crépusculaire à DEUX SEUILS, avec HYSTERESIS, agissant sur plusieurs sorties.
MATÉRIEL
Comme d'habitude :
 
Penser à basculer les micro-switchs sur ON.
 
Retour sur le programme proposé dans «Tester une LDR»
Ce programme n'a qu'un intérêt didactique.
Son défaut majeur est que, si le niveau de luminosité oscille autour de A=140, on risque d'avoir des allumages et extinctions erratiques et rapides. C'est ce qui se produit quand la lumière croît ou décroît très lentement, comme dans la réalité.
En effet, le parcours de la boucle [C.A.N. 4,A] - [A>140] - [Cx=ON] est extrêmement rapide (quelques micro-secondes).
La lecture de l'entrée C4 et le test de la variable A sont donc effectués des milliers de fois par seconde, avec le risque de voir clignoter irrégulièrement les sorties C1 et C2.
PETITE AMÉLIORATION :
 
On intercale avant chaque passage par l'instruction [C.A.N.] une temporisation de 2 secondes.
La lecture de l'entrée C4 et le test de la variable A n'auront lieu que toutes les 2 secondes.
Sauf si la luminosité se maintient très proche du niveau 140 ET pendant suffisamment longtemps on ne verra pas apparaître de fonctionnement intempestif.
 
Malgré tout ce fonctionnement n'est encore pas satisfaisant.
 
 
UN SEUIL AVEC HYSTÉRÉSIS :
Cette fois-ci le programme commande uniquement la sortie C1.
 
Nous allons examiner le comportement du programme pour trois valeurs de luminosité : 110, 130 et 150.
 
Analyse du fonctionnement en luminosité croissante :
A = 110 :
  • test A>140 ⇒ NON : on passe au deuxième test et C1 reste inactive.
  • test A<120 ⇒ OUI : [Désactiver 1] (donc C1 reste inactive) et retour au début de la boucle.
 
A = 130 :
  • test A>140 ⇒ NON : on passe au deuxième test et C1 reste inactive.
  • test A<120 ⇒ NON : retour au début de la boucle et C1 reste inactive.
 
A = 150 :
  • test A>140 ⇒ OUI : [Activer 1] et retour au début de la boucle.
    Le deuxième test n'est donc pas effectué.
 
Analyse du fonctionnement en luminosité décroissante :
A = 150 (C1 est donc déjà active) :
  • test A>140 ⇒ OUI : [Activer 1] (donc C1 reste active) et retour au début de la boucle.
    Le deuxième test n'est donc pas effectué.
 
A=130 :
  • test A>140 ⇒ NON : on passe au deuxième test et C1 reste active.
  • test A<120 ⇒ NON : retour au début de la boucle et C1 reste active.
 
A = 110 :
  • test A>140 ⇒ NON : on passe au deuxième test et C1 reste active.
  • test A<120 ⇒ OUI : [Désactiver 1] et retour au début de la boucle.
 
Pardonnez-moi de vous avoir infligé ce descriptif.
De toutes façons la mise au point d'un programme passe forcément par l'inventaire chronologique des différentes situations possibles.
Bref...
Dans l'inventaire ci-dessus on constate que le basculement de la sortie C1 se fait pour A=140 en lumière croissante, et pour A=120 en lumière descendante.
Ainsi, même si le niveau lumineux ambiant est instable avec de faibles amplitudes, les basculements intempestifs ne peuvent plus se produire.
 
 
 
DEUX SEUILS AVEC HYSTÉRÉSIS, POUR DEUX SORTIES :
Programme_test_INTERRUPTEUR_CREPUSCULAIR
 
Cet organigramme n'est qu'une extension du précédent.
 
Juste une particularité : le retour au début de la boucle ne s'effectue qu'APRÈS avoir parcouru les deux groupes de tests.
On peut aussi exprimer la chose de la façon suivante :
 
«on traite le premier problème (sortie C1) puis le deuxième (sortie C2)
et seulement ensuite on boucle».
 
Je vous laisse le soin de faire vous-même l'inventaire des situations possibles.
 
 
Remarques :
Tous ces programmes sont des exercices didactiques.
Le dernier proposé fonctionne avec 2 seuils qui attaquent deux sorties différentes.
Rien n'empêche, pour un même seuil, d'attaquer plusieurs sorties simultanément.
Rien n'empêche d'envisager trois seuils différents. Le programme ne sera pas plus compliqué. Par contre tout l'art va consister à régler les niveaux de basculement !

 

 

© 2020 par Hubert SPERI – Créé avec Wix.com

WIX.png
BB1601_loco_2A.png