- Electronique

Electronique Générale

& Programmable

à l'usage du Modélisme

Sommaire:

Sur cette page:

- Introduction - Présentation

- Programmation des MicroContrôleurs en BASIC

- Logiciels et matériel nécessaires pour programmer facilement vos MicroContrôleurs en BASIC

- Programmation "In Situ"

- Notions de Programmation structurée universelle

Sur les pages annexes: (Voir Plan du Site)

- Matricage des claviers : matrice carrée, matrice triangulaire, matrices à diodes (jusqu'à 112 switches sur 8 bits !)

-

-

Introduction - Présentation

Le sujet est résolument vaste et fait déjà l'objet d'une multitudes de pages traitées sur le Web.
Vous en trouverez quelques références, certes pas exhaustives, à la page des Liens.

Pour ma part, cela fait plusieurs années que j'ai décortiqué, étudié, développé et amélioré les sytèmes d'extension de voies communément appelés modules Multi-Swiches et Multi-Prop.
Ce sont des systèmes électroniques qui permettent d'utiliser une voie de notre ensemble RC et ainsi "transformer" une simple sortie du récepteur en plusieurs sorties Tout ou Rien (T/R) ou Proportionnelles, par codage du signal émis par l'émetteur.

Mon dernier proto permet ainsi plusieurs dizaines de fonctions T/R par voie !

Depuis la mise en oeuvre, relativement facile, des MicroContrôleurs (µC) par le modéliste particulier, il n'y a plus que son imagination pour limiter le terrain d'expérimentation de ces merveilleux composants électroniques programmables... de vrais petits "ordinateurs" hyper mini !

Je me suis ainsi fait la main avec les µC Basic-Stamp de Parallax, pour la phase de conception des prototypes.
Les programmes et applications étant ensuite transférés dans des PIC grâce à un programmateur, évidemment "fait maison".
Je me penche aujourd'hui, parallèlement à ces composants qui gardent leur facilité d'usage, sur les AVR de Atmel.
Ces derniers disposent de multiples fonctions intégrées (ADC, PWM, Interruptions, ...), de commandes plus étendues, et tout cela pour un prix extrêmement avantageux !

Je programme très facilement tous ces MicroContrôleurs en language assimilé BASIC, après élaboration d'un algorithme structuré.

Ces µC m'ont permis de mettre au point des modules d'extension de voies (T/R ou Prop) et autres safe-servo, servo-treuil puissants, ..., ...

J'avais d'ailleurs commencé l'écriture d'un ouvrage technique ... que les alléas de la Vie m'ont empêcher de poursuivre à ce jour !

Mon projet actuel est la réalisation d'un émetteur, et de son codeur, ergonomique spécialement concu pour le modélisme naval, comprenant des commandes disposées spécialement pour des maquettes à moteur, ou à voile, et reprenant de multiples interrupteurs et potentiomètres pour les extensions de voies.

Mon "laboratoire" flottant expérimental étant alors mon "très-ptit-gros" remorqueur Zeehondje ... qui ne manque pas de place pour y disposer des "tonnes" de circuits et de batteries !

Programmation des MicroContrôleurs en Basic

L'utilisation des microcontrôleurs, de toutes familles, est vraiment à la portée de tous car ils peuvent facilement être programmés en utilisant un language ne nécessitant pas un long apprentissage: Le BASIC !
Ce language n'enlèvera rien à l'efficacité de vos programmes en comparaison de ceux écrits en C, C+, Assembleur, ..., ..., ...

Comme dans tout language programmé, il faudra impérativement veuiller à écrire vos algorithmes sans erreur de structure !
Toutes ces erreurs de structures conduisent à la saturation de la pile opérationnelle de votre µC et ... à son plantage assuré, en cours de route, alors que tout semblait bien aller le jour précédent !
Problème classique d'un "mauvais" programme.
Vous-vous éviterez bon nombre de ces désagréments en appliquant les règles de la programmation structurée.

Logiciels et matériel nécessaires pour
programmer facilement vos MicroContrôleurs en Basic

Basic STAMP

Parallax®

La grande famille des Basic Stamp

Edition / Interpretation / Programmation: Basic Stamp Editor (Parallax) (In Situ Programming) + Câble série RS232

Les dernières versions du programme et des Stamps permettent des commandes avancées (Boucles conditionnelles complètes, LCD, ...)

PIC,

Stamp to PIC

MicroChip®

PIC, programmateur // et support Zif optionnel ou programmateur Série, type "JDM"

Edition / Compilation: Pic Basic Pro Compiler
Programmation: EPIC Win + Interface // EPIC Plus Programmer (MicroEngineering Labs, inc)

Le programme Stamp demande parfois quelques adaptations pour le Pic Choisi. Voir les spécifications du Pic Basic Pro Compiler.

Enfin, pour plus de facilité, adaptez vos boards à Pic pour une programmation "In-Situ" exécutée directement sur votre platine sans devoir retirer le µC (Voir ci-dessous)

Choisissez toujours une interface de programmation permettant de disposer de 13,5 V pour la tension de programmation (Vpp). Des programmateurs de type JDM ne permettent pas tous la programmation en "haute" tension et se limitent à 5 volts !

Divers programmes dits "d'environnement" permettent un lien entre les programmes de compilation, d'assemblage et de programmation tout en restant dans un même environnement Windows.
Leur usage permet une grande souplesse car il évite de lancer plusieurs programmes successivement. Tout est géré par cet unique environnement.

Liste non exhaustive: CodeStudio, CodeDesigner, ...

AVR

Atmel®


AVR et programmateur ISP USB

Edition / Compilation: BASCOM AVR (Atmel)
Programmation: AVR Studio 4 + interface USB STK500 Compatible (ISP: In Situ Programming)

Programmation "In Situ" ISP - ICSP

La programmation ISP (In Situ Programming) ou ICSP(In Circuit Serial Programming) offre une très grande souplesse et une certaine sécurité "mécanique" à vos µC.
En effet, il n'est plus nécessaire de leur imposer les manipulations et les nombreux allers-retours entre leur platine et le programmateur, avec tous les risques d'endommagement de leurs fines pattes de connexion.

Pour cela, il faudra simplement prévoir quelques aménagements spécifiques sur votre platine définitive, consistant principalement à isoler les pins servant à la programmation, RB6(Ck-16F84) et RB7(Data-16F84), et ajouter 5 pinheaders pour la programmation: VPP/MCLR, Switched VDD, Data, Clock, Gnd qui permettront le raccordement du µC vers son programmateur externe.

Notions de Programmation structurée

La programmation structurée est un language de programmation universel permettant d'élaborer des algorithmes sains, dépourvus d'erreurs de structures.
Nous pourrions résumer les impératifs de structures "classiques" en disant que chaque boucle doit avoir une seule entrée et une sortie; Aucune boucle ne peut restée ouverte; tout départ vers une instruction ou une routine doit obligatoirement revenir à son point d'appel dès qu'elle a été exécutée, ...
Evitez ainsi et surtout les "plats de spaghettis" provoqués par les instructions GOTO qui sont absolument à proscrire !!!
Il ne peut pas y avoir de "cul de sac", ou de "voies sans issue" dans vos programmes, ...

La programmation structurée utilise ses commandes propres et très limitées.
Ce language, cette écriture ne servent donc qu'à assurer une structure parfaite à votre prochain algorithme.
Un programme écrit dans ce language "universel" simple, assez proche du Basic, devra donc ensuite être transposé dans le language de votre application finale en utilisant alors les commandes propres de ce language final, dépendant aussi du µC utilisé dans l'application.

En fait, nous avons déjà tous composé des lignes de codes en s'appliquant à respecter l'ordre des tâches à effectuer mais sans jamais trop se soucier des problèmes de structures qui apparaissent inévitablement dès que la routine commence à devenir plus complexe.

Ces erreurs, plutôt assimilables à une mauvaise habitude "chronique" proviennent de l'usage, faussement facile, de certains "anciens" langages de programmation dont les lignes de code étaient labellisées ou numérotées.

Ces lignes étaient alors exécutées dans l’ordre de leurs numéros de lignes.

Ainsi dit, nous ne voyons pas vraiment où peuvent se poser les problèmes me direz-vous !

Mais, en fait, tous ces langages comportent une instruction de branchement de type "Allez à cet endroit du programme", généralement un "GOTO"; instruction qui envoie directement le programme à la ligne spécifiée.

Le problème est que ce type de commande ne comporte pas d’instruction de "retour" comme Endif, Enddo, Return, ... qui " ferment " le bloc appellé.

On se retrouve alors en plein milieu d'un programme, sous un ou plusieurs blocs qui devraient encore être exécutés, mais où le système ne sais plus où il est, ni comment il doit poursuivre ou repartir pour exécuter correctement les autres commandes dans un ordre précis qui était prévu initialement par le programmeur.

Prenons l’exemple simple d’une boucle conditionnelle classique " Si … Alors … Sinon " ; "If .. Then .. Else"

Programmation non structurée

1000 Si [telle condition] Alors Aller en 1100 Sinon Aller en 1200

1100 <instruction 1>

1110 etc.

1120 etc.

1190 Aller en 1400

1200 <instruction 2>

1210 etc.

1220 etc.

1350 Aller en 1400

1400 Suite de l'agorithme

Un programme écrit de cette façon se présente comme une suite de branchements emmêlés les uns dans les autres.

Imaginez cette manière d'écrire dès qu'une boucle conditionnelle en appellerait une ou plusieurs autres (boucles imbriquées).

Outre le fait que cette structure ne favorise pas la lisibilité du programme, c’est une source importante d’erreurs, car tôt ou tard on oubliera un " aller à ", on en mettra un de trop ou le programme perdra tout simplement le fil d'Ariane qu'il est censé suivre du début à la fin de son exécution !

Et pour autant que l'algorithme soit conséquent, ces divers GOTO créeront rapidement une jungle inextricable; un véritable plat de spaghettis !

A l’inverse, la programmation structurée, surtout si l’on prend soin de rationaliser la présentation "papier" en mettant des lignes de commentaires et en pratiquant l’indentation, évitera ces erreurs, et elle révèlera la structure logique du programme de manière très claire.

Programmation Structurée

IF [telle condition] Then

<instructions 1>

Else

<instructions 2>

Endif

Suite immédiate du programme

D'une manière générale, il faut éviter d'utiliser une commande de branchement qui "sort" le pointeur du corps principal du programme, qui le dirige vers une partie basse du programme et qui ne lui permet pas de revenir à son point d'appel dès que le morceau de code conditionnel a été exécuté.

Ainsi, d'une manière générale, l' instruction GOTO est à proscrire impérativement dans le corps de tous vos programmes.

On lui préfèrera sans retenue des appels à des sous-routines (sortes de sous-programmes écrit en parrallèle du code principal) qui, elles, se terminent par une instruction de type "Return" qui renvoie exactement le pointeur dans le programme principal, là où il l'avait quitté.

Exemple d'un programme écrit en language structuré universel et adapté pour une programmation:
1) dans un PIC
2) dans un BasicStamp:

' Déclaration des Variables :

   IN      Var       Word ‘1250/1875/2500 – BSIIsx

   i        Var       Nibble ‘(Word for PIC) 0 à 7

   Etat   Var       Nibble ‘(Word for PIC) (0,1,2)

    S0     Con     800 ‘Adapter en fonction du Quartz µC !

   S1     Con     1562
   S2     Con     2187
' Infos matériel

In/Out :            Pulsin                                      0

                        7 Sorties (*)                             1 à 7

                        Témoin dysfonctionnement    8

·         Suivant le type de codeur, il est possible de gérer 7, 8, 15 ou 16 sorties T/R.
   Le Pic doit cependant compter autant de in/out !
   Adapter les valeur / échantillonages, relatives au temps, en fonction du quartz utilisé !

Programme Structuré
universel

PIC Basic Pro Compiler (.pbp) pour PIC
'Pic 16 Mhz

Basic-Stamp V2.5 (.bsx) pour BasicStamp
'BasicStamp IIsx

BEGIN
Do While i=i

<Lire les impulsions sur 0, et placer dans IN>

    GoSub Tri

    GoSub Sorties

Enddo

END

‘------ SUBROUTINES ------------

SUB Tri

IF IN <S0 0 Then

<Allumer un témoin de dysfonction>

Let Etat = 1     ‘Voie OFF

Else

    <Désactiver témoin de dysfonction>

    IF IN <=S1 Then       ‘SeuilSynchro

    Let I=0             ‘RAZ Var indicée

    Let Etat=0   ‘Synchro

    Else

         IF IN <S2 Then ‘SeuilOFF

         Let Etat=1   ‘Voie OFF

         Else

         Let Etat=2   ‘Voie ON

         Endif

    Endif

Endif

Endsub ‘and return
‘ ----------------------------------------------

SUB Sorties

IF Etat<>0 Then

    IF Etat=1 Then

    <Placer i à 0>      ‘Voie OFF

    Else   ’Etat=2

    <Placer i à 1>      ‘Voie ON

    Endif

    Let i=i+1

Endif

Endsub ‘and return

Debut:

Pulsin 0,1,IN

GoSub Tri

GoSub Sorties

Goto Debut 'Le seul GOTO permis pour fermer la boucle principale !

END

‘------ SUBROUTINES ------------

Tri:

IF IN <256 Then

High 8    ‘Témoin de dysfonction

Let Etat = 1     ‘Voie OFF

Else

    Low 8      ‘Désactive témoin dysfonction

    IF IN <=499 Then      ‘<=1562 &&&

    Let i=0                    ‘RAZ Var indicée

    Let Etat=0   ‘Synchro

    Else

         IF IN <699 Then   ‘<2187 &&&

         Let Etat=1   ‘Voie OFF

         Else

         Let Etat=2   ‘Voie ON

         Endif

    Endif

Endif

Return

‘ -------------------------------------------

Sorties:

IF Etat<>0 Then

    IF Etat=1 Then

    Low i      ‘Voie OFF

    Else        ’Etat=2

    High i     ‘Voie ON

    Endif

    Let i=i+1

Endif

Return

Debut:

Pulsin 0,1,IN

GoSub Tri

GoSub Sorties

Goto Debut 'Le seul GOTO permis pour fermer la boucle principale !

STOP

‘------ SUBROUTINES ------------

Tri:

    IF IN <S0 Then

    High 8    ‘Témoin de dysfonction

    Etat = 1 ‘Voie OFF

    Else

      Low 8          ‘Désactive témoin dysfct

       IF IN <S1 Then      ‘<=1562 &&&

        i=0           ‘RAZ Var indicée

        Etat=0 ‘Synchro

       Else

         IF IN <S2 Then   ‘<2187 &&&

         Etat=1    ‘Voie OFF

         Else

         Etat=2    ‘Voie ON

         Endif

       Endif

    Endif

Return

‘ -----------------------------------------

Sorties:

    IF Etat<>0 Then

         IF Etat=1 Then

         Low i      ‘Voie OFF

         Else        ’Etat=2

         High i     ‘Voie ON

         Endif

         i=i+1

    Endif

Return

Dans le language structuré universel, vous constaterez que les commandes propres aux languages finaux sont remplacés par des < expressions verbales >.
Celles-ci seront remplacés par les commandes ad-hocs, une fois le language choisi en fonction du matériel à programmer.
La structure parfaite du language structuré sera cependant respectée, garantissant ainsi un programme final sans défaut de fonctionnemnt.

Bref, ce sont là toutes les bases de la Programmation Structurée, développées plus amplement ici que je vous invite à appliquer systématiquement !

Astuces - Programmation structurée

Se voulant être universel, pour pouvoir ensuite être transposé dans le language de votre application finale, le nombre d'instructions "structurelles" disponibles en programmation structurée est particulièrement limité.

Mais nous avons cependant vu que les commandes d'exécution, particulières et propres à chaque matériel qui sera utilisé est écrit en language verbal clair. Exemple: <Saisir température et placer dans la Variable XYZ>, <Allumer brûleur>, < Afficher le niveau>, <Déclencher l'alarme>, ..., ...

Il faudraainsi utiliser quelques routines habituelles pour « simuler » des fonctions, parfois toutes faites dans votre language final, et auxquelles ont est souvent bien confortablement habitués ... mais qui ne sont pas admises en programmation structurée !

Exemples non exhaustifs:

FOR … NEXT

Let J = 0

Do while J<=9 ‘ Boucle exécutée 10x, tant que que J<=9

< instructions >

Let J = J+1 ‘ i = 0 à 10, mais lorsque i=10, le pointeur remonte mais

Enddo ‘ la boucle ne sera plus exécutée.

Let J = 0

Do ‘ Ouverture de boucle

< instructions >

Let J = J+1 ‘ Boucle exécutée 10x, jusqu’à ce que J=10

Until J<10 ‘ i= 0 à 10, mais lorsque i =10 la boucle ne s’exécute plus

‘ et le pointeur ne remonte plus. Le programme continue de suite.

MOD (calcul du reste d’une division)

MOD (n/d) =  n - d*INT(n/d)  
 

  5 3
-3 1
2

Soit la division A/B

Partie entière : K= A/B Si la variable n’a pas été définie en virgule flottante, le processeur ne travaille qu’en mode entier.

Reste (MOD) = A-KB

Exemple:

K = 5/3 = 1,~~667~~

MOD 5/3 = 5-1x3