traitement parallèle

REVUE DE
CONCEPTION REVUE DE CONCEPTION
Cog 0 Cog 1 Cog 2 Cog 3 Cog 4 Cog 5 Cog 6 Cog 7
Compteur A + PPL
Compteur B + PPL
Générateur vidéo
Reg. de sortie E/S
Reg. de direction E/S
512 x 32
RAM
Processeur
Compteur A + PPL
Compteur B + PPL
Générateur vidéo
Reg. de sortie E/S
Reg. de direction E/S
512 x 32
RAM
Processeur
Compteur A + PPL
Compteur B + PPL
Générateur vidéo
Reg. de sortie E/S
Reg. de direction E/S
512 x 32
RAM
Processeur
Compteur A + PPL
Compteur B + PPL
Générateur vidéo
Reg. de sortie E/S
Reg. de direction E/S
512 x 32
RAM
Processeur
Compteur A + PPL
Compteur B + PPL
Générateur vidéo
Reg. de sortie E/S
Reg. de direction E/S
512 x 32
RAM
Processeur
Compteur A + PPL
Compteur B + PPL
Générateur vidéo
Reg. de sortie E/S
Reg. de direction E/S
512 x 32
RAM
Processeur
Compteur A + PPL
Compteur B + PPL
Générateur vidéo
Reg. de sortie E/S
Reg. de direction E/S
512 x 32
RAM
Processeur
Compteur A + PPL
Compteur B + PPL
Générateur vidéo
Reg. de sortie E/S
Reg. de direction E/S
512 x 32
RAM
Processeur
Broches
E/S
Sens des broches
Sortie des broches
Entrées des broches
Compteur système
Bus de données
Bus d'adresses
Compteur
système
HORLOGE
32
32
32
16
32
32 32
P31
P30
P29
P28
P27
P26
P25
P24
P23
P22
P21
P20
P19
P18
P17
P16
P15
P14
P13
P12
P11
P10
P9
P8
P7
P6
P5
P4
P3
P2
P1
P0
P4
P5
P6
P7
VSS
BOEn
RESn
VDD
P8
P9
P10
P26
P25
P24
VDD
XO
XI
VSS
P23
P22
P21
P20
P3 P2 P1 P0
VDO
VSS
P31 P30 P29 P28 P27
P11
P12 P13 P14 P15
VSS
VDD
P16
P17
P18 P19
VDD
VSS
BOEn
RESn
SOFTRES
XI
XO
OSCENA
OSCMODE 2
PLLENA
CLKSEL
RESET
HORLOGE
2
3
SOFTRES
PLLENA
OSCENA
OSCMODE
CLKSEL
1
2
3
4
5
6
7
8
9
10
11
33
32
31
30
29
28
27
26
25
24
23
12 12 14 15 16 17 18 19 20 21 22
44 43 42 41 40 39 38 37 36 35 34
Détecteur
de tension
(~10ms)
Détecteur
de baisse de
tension
Oscillateur
à quartz
CC 0 80 MHz
(4 - 8 MHz avec
horloge PLL)
Retard de
réarmement
(~50 ms)
Oscillateur RC
12 MHz / 20 MHz
Horloge PLL
1x, 2x, 4x, 8x,
16x,(16x doit être
64 - 128 MHz)
Sélecteur
d'horloge
(MUX)
3
5
3
Séquenceur de bus
RAM 8192 x 32
ROM 8192 x 32
Activation Cog
Bits de verrouillage (8)
Confi guration
Registre
Plate-forme
Compteur
système Broches
E/S
Cog
0
Cog
7
Cog
1
Cog
6
Cog
2
Cog
5
Cog
4
Cog
3
Plate-forme
RAM, ROM,
Confi guration,
Contrôle
Interaction Plate-forme/Cog
20 eTech - NUMÉRO 3 eTech - NUMÉRO 3 21
De temps en temps une nouveauté fait son apparition. Ça fait maintenant de
nombreuses années que le développement des microcontrôleurs emprunte
les mêmes voies : soit le même processeur « coeur » de base entouré d'autres
périphériques, soit le processeur lui-même rendu de plus en plus puissant.
Lancez-vous dans le
traitement parallèle
avec le Parallax Propeller
™
Tous les microcontrôleurs ont en commun un
processeur unique qui s'appuie sur une logique
dédiée et spécialisée assurant des fonctionnalités
telles qu'une sortie de modulation en largeur
d'impulsion (PWM) et une entrée de comptage par
impulsions. Le Propeller de Parallax représente une
évolution majeure dans l'approche de conception.
Ce dispositif comporte huit processeurs 32 bits ou
« COG » avec une logique de support minimale et
un matériel d'E/S des plus élémentaires (Fig.1). À
première vue, cet agencement pourrait susciter
des réactions du genre : « Super, je vais pouvoir
implémenter ce projet de réseau neuronal en utilisant
chaque COG pour exécuter fondamentalement le
même programme. »
Mais bien qu'un traitement purement parallèle puisse
effectivement être un bon usage pour le Propeller,
je ne pense pas que la conception ait été motivée
par ce type d'application. L'idée est de laisser à
l'ingénieur un maximum de contrôle sur le système
périphérique dans une application donnée. Vous
pouvez tout de même faire exécuter le programme
de haut niveau par un COG unique qui sous-traite les
tâches de niveau inférieur, comme les E/S série, à un
autre COG en fonction des besoins. Mais ce qui est
vraiment fascinant sur ce dispositif c'est sa capacité
à se reconfi gurer sous contrôle d'un programme
afi n de s'adapter aux besoins du moment et
d'arrêter ensuite les processus quand ils ne sont
plus nécessaires, en réaffectant éventuellement les
ressources des processeurs à une tâche totalement
différente. L'horloge du processeur est également
sous contrôle d'un programme, ce qui permet de
diminuer la consommation d'énergie si une haute
vitesse n'est pas nécessaire pour mettre en œuvre
des E/S lentes telles que RS-232.
Le kit de démarrage
Le kit contient une toute petite carte de démo
équipée de nombreux connecteurs d'E/S dont
certains vous surprendront : sortie VGA vers un
moniteur, sortie TV, connecteurs clavier et souris
PS/2. Les sorties vidéo sont disponibles car, dans
sa ROM de ressource centrale, la puce contient la
table de recherche d'un générateur de caractères.
Le seul port d'E/S « traditionnel » est l'USB
provenant de la puce FTDI intégrée. La fonction
UART qui commande ce dispositif est bien-entendu
entièrement mise en œuvre par logiciel et s'exécute
sur l'un des COG. Toutes les communications avec le
logiciel IDE du PC, le Propeller Tool, se font via le port
USB. La carte est équipée d'une mémoire EEPROM
série qui communique avec le Propeller via un bus
I2C ce qui, vous l'avez deviné, est mis en œuvre par
un logiciel exécuté sur un COG. Les programmes
utilisateur disposent ainsi d'une mémoire non
volatile. Ces routines d'E/S sont chargées à partir de
la ROM du système lors du Reset de façon à ce que
les programmes puissent être téléchargés à partir
du PC ou de l'EEPROM, mais sont ensuite arrêtées
avant que le programme utilisateur commence à
s'exécuter. Si votre programme a besoin de ces
ressources d'E/S, il devra les charger et leur affecter
un ou plusieurs COG en fonction des besoins.
Si cette méthode peut sembler peu commode à
première vue, elle évite d'encombrer inutilement
l'espace mémoire avec des ressources superfl ues.
Propeller Tool
L'IDE fourni avec le kit de démarrage est appelé
Propeller Tool et permet l'édition de programme,
la compilation du langage de haut niveau Spin et
le téléchargement sur la carte de démo. Vous avez
la possibilité de programmer en Spin, en langage
assembleur, ou avec une combinaison des deux. Il va
de soi que l'assembleur permet une exécution plus
effi cace et plus rapide et on retrouve le compromis
classique entre un développement rapide et une
exécution rapide.
L'écran de l'éditeur est très coloré et l'attribution
automatique des différentes couleurs pour coder
les blocs aide à mieux comprendre la structure du
programme. Deux options sont disponibles pour
télécharger et exécuter : compiler et exécuter
dans la RAM d'un COG, et compiler et envoyer
dans l'EEPROM externe où le programme est
automatiquement chargé dans la RAM par le
chargeur d'amorçage. La première option convient
mieux au développement, car le programme est
seulement transféré dans la mémoire non volatile
quand le code fonctionne.
Utilisation de la carte de démo
Pour illustrer certaines des principales
caractéristiques de la programmation du Propeller,
une tâche a été mise au point pour commander
la vitesse d'un petit moteur à courant continu
en utilisant la modulation en largeur d'impulsion
(PWM). Deux boutons-poussoirs fournissent les
entrées d'augmentation et de baisse de la vitesse
(Speed Up et Speed Down). La capacité des
ports d'E/S étant insuffi sante pour commander le
moteur utilisé, un circuit pont en H a été construit
avec la moitié d'un driver quadruple L293D, monté
ensuite sur la carte de circuit imprimé avec deux
commutateurs « Tact », des résistances « Pull up »
et des condensateurs de découplage (voir la photo
page 23). Notez l'utilisation de la variante D de ce
composant, qui est dotée de diodes de protection
intégrées pour contrôler les charges inductives.
Sur les 32 ports du Propeller, seuls les Ports 0 à 7
sont disponibles pour l'utilisateur, les autres étant
réservés aux bus EEPROM, etc. sur cette carte de
démo. Le Propeller est un composant +3,3V bien
que les deux alimentations stabilisées +3,3V et +5V
soient également disponibles. Ainsi, la logique du
L293D fonctionne avec l'alimentation +3,3V, alors
que sa broche d'alimentation de moteur séparée
est connectée au +5V. La connexion à la terre ou 0V
qui peut être reliée à la pince crocodile d'une sonde
d'oscilloscope est un petit détail mais très utile.
Programmation en Spin
Une solution de programme possible pour
commander le moteur est présentée dans le Listing
1 (voir page 22). Il ne s'agit pas d'une solution
optimale mais elle illustre certaines des particularités
essentielles de la programmation du Propeller.
L'objectif est d'utiliser deux COG ; l'un commande
la sortie PWM avec un rapport marque/espace défi ni
par la variable globale Ratio, l'autre surveille deux
entrées de bouton-poussoir et défi nit la valeur de
Ratio. La fréquence du PWM est de 1 kHz.
Les instructions CON confi gurent deux constantes
système et défi nissent la vitesse de l'horloge.
Nous avons opté pour une horloge de 20 MHz de
sorte que le multiplicateur interne PLL est défi ni à
4 étant donné le quartz 5 MHz fourni avec la carte.
Ensuite, les instructions VAR défi nissent les variables
globales : Ratio comme indiqué plus haut, Period
et Stack qui affecte l'espace de pile pour le
deuxième COG.
La première méthode publique, PUB Main, effectue
les tâches d'initialisation habituelles, dont la défi nition
d'une valeur initiale de Ratio équivalente à 50 % du
PWM. Chaque COG possède une simple unité «
Compter/Capturer » reposant sur certains registres
et quelques éléments de logique. Il y a deux
compteurs identiques, A et B, chacun composé de
trois registres : CTR, FRQ et PHS. CTR défi nit le
mode de fonctionnement, PHS est l'accumulateur
contenant la valeur courante et FRQ est ajouté à
PHS en fonction des besoins. Ici, c'est le compteur
A qui est utilisé. Pour commencer, le registre CTRA
est défi ni pour sélectionner le mode PWM et le Bit
31 de PHSA est relié au Port 0 de sortie. FRQA est
défi ni à 1 de sorte que PHSA est incrémenté de un à
chaque cycle de l'horloge système.
Fig. 1
Suite page 22 >
De Dr William Marshall, RS Components

REVUE DE
CONCEPTION REVUE DE CONCEPTION
22 eTech - NUMÉRO 3 eTech - NUMÉRO 3 23
Listing 1. Code source SPIN pour le programme de démonstration PWM
Vient ensuite l'instruction vraiment intéressante :
COGNEW. C'est elle qui lance le deuxième COG.
Jusqu'ici, c'est COG 0 qui a tout fait : l'exécution du
chargeur d'amorçage et ensuite la première partie de
notre programme. COGNEW lui indique de charger la
méthode publique Buttons dans le COG libre suivant,
dans ce cas COG 1, et de lancer l'exécution. Il lance
ensuite la méthode Toggle et l'exécute à partir de
maintenant. L'une des particularités du Propeller est
que les 32 lignes de port GPIO sont partagées par
tous les processeurs. Chaque COG possède son
propre registre de Direction de port, dont chaque
sortie est mise en fonction OU avec le registre de
COG suivant (voir la Fig.1 page 20). Un COG qui a
besoin d'un port de sortie doit définir le bit approprié
dans son registre de direction au 1 logique. Une fois
défini, il permet également à la sortie correspondante
du registre d'E/S du COG de configurer la broche
d'E/S. Il faut veiller à ce que deux COG n'essayent
pas d'utiliser la même ligne de port pour la sortie,
Car le programme aurait alors un comportement
inattendu ! L'entrée d'un port est complètement
indépendante et n'importe quel COG peut lire l'état
de n'importe quelle broche de port à tout moment.
Un COG peut contrôler sa propre sortie ou même
surveiller ce que font les autres COG sur les broches
de port qu'ils ont configurées comme sorties.
Le Propeller n'ayant pas de système d'interruption,
plusieurs instructions sont utilisées pour
interrompre l'exécution du programme jusqu'à
ce qu'un événement se produise. WAITCNT
suspend l'opération pour le nombre spécifié
de cycles d'horloge système en comparant
la valeur d'un nombre cible à la valeur
du compteur système CNT. Dans PUB
Toggle, PHSA est chargé avec la valeur
négative (complément à 2) de Ratio. Ceci
définit le Bit 31 ou le « bit de signe » de
PHSA au 1 logique. Comme ce bit est relié
au Port 0, la sortie PWM passe aussi à l'état
haut. PHSA est maintenant automatiquement
incrémenté à la fréquence de l'horloge système
en lui ajoutant FRQA. Après Ratio cycles d'horloge,
PHSA atteint zéro et le Bit 31 passe au 0 logique,
ce qui correspond à la fin de l'impulsion PWM.
Pendant ce temps, le COG attend à l'instruction
WAITCNT pendant la durée Period. PHSA continue
naturellement à s'incrémenter, mais la fin de
Period est atteinte bien avant que PHSA atteigne à
nouveau une valeur haute du Bit 31. Quand le délai
de WAITCNT expire, le cycle se répète, PHSA étant
rechargé avec –Ratio. Nous avons donc ajouté des
opérations parallèles en déterminant la largeur de
l'impulsion avec le Compteur, alors que de son côté
le programme du COG définit la période. C'est ainsi
que la forme d'onde PWM au Port 0 est générée
par Toggle.
L'instruction WAITPNE dans la méthode Buttons
attend que le Port 1 ou le Port 2 (ou les deux) passe
au 0 logique. Autrement dit, elle attend qu'un bouton
soit appuyé. L'avantage de ces instructions Wait
est que l'opération du COG est suspendue, ce qui
permet une réduction de consommation de plus de
85 %. Vous pouvez constater que le COG exécutant
Buttons passe la plupart de son temps « endormi
», et ne se réveille que quand c'est nécessaire.
Les instructions max (<#) et min (#>) dans Buttons
donnent les limites haute et basse de Ratio.
Encore plus vite
On pourrait s'attendre à ce que des programmes
exécutés par un interpréteur intégré, dans ce
cas SPIN, soient plus lents que des programmes
en assembleur natif. Dans une certaine mesure,
l'architecture unique du Propeller creuse la différence
de vitesse. En effet, le code SPIN de l'utilisateur
réside dans une RAM centrale partagée alors que
chaque COG exécute l'interpréteur dans sa propre
mémoire locale. La plate-forme permet d'accéder
aux ressources centrales selon une séquence
temporelle stricte et un COG donné peut être
contraint à attendre son tour. Le code machine
de l'assembleur est stocké et exécuté dans la
mémoire locale du COG ce qui permet d'augmenter
considérablement le débit.
Ouvrages à consulter
Programming and Customizing the
Multicore Propeller Microcontroller
Shane Avery et al ISBN 978-0-07-166450-9
McGraw Hill
Liste des composants
Code commande.
Kit de démarrage Propeller 32330 405-571
Driver demi-pont quadruple L293DNE 526-868
Commutateur bouton-poussoir Tact 479-1390
Moteur CC RE280 238-9709
< Suite de la page 21 >
Toujours plus en ligne...
Une version plus complète de
cet article et les chiers du code
source SPIN sont disponibles sur
rs-components.com/etech
‘’ **********************************************************************************
‘’ * Simple régulateur de vitesse de moteur CC utilisant des compteurs pour varier *
‘’ * le rapport marque/espace du PWM de 0 à 100 % *
‘’ **********************************************************************************
‘’Port 0 = Sortie PWM
‘’Port 1 = Entrée du bouton Speed Up
‘’Port 2 = Entrée du bouton Speed Down
CON
_clkmode = xtal1 + PLL4X
_clkfreq = 20_000_000
VAR
word Ratio ‘Ratio = largeur de l'impulsion du PWM
word Period ‘Period = période du PWM
long Stack[9] ‘Espace pile pour COG 1
PUB Main
‘’Initialisation des ports, des compteurs et démarrage du programme
Ratio := 10000 ‘PWM initial 50 %
Period := 20000 ‘Dénit la période du PWM
ctra[30..26] := %00100 ‘Congure le Compteur A au mode NCO/PWM
ctra[5..0] := %00000 ‘Associe le Compteur APIN au Port 0
frqa := 1 ‘Dénit l'incrément de compteur à 1
dira[0..2] := %100 ‘Dénit les Ports 0 = sortie , 1 & 2 = entrée
cognew(Buttons, @Stack) ‘Démarre l'exécution de la routine Buttons sur COG 1
Toggle ‘COG 0 exécute la routine de génération du PWM
PUB Toggle | Time
‘’COG 0 produit un signal PWM avec une largeur d'impulsion dénie par la variable Ratio
Time := cnt ‘Dénit le temps de base en utilisant le Compteur système
repeat ‘Répète les 3 lignes suivantes indéniment
phsa := -Ratio ‘Charge la largeur d'impulsion inversée dans PHS
Time += Period ‘Time = Time + Period
waitcnt(Time) ‘Attend pendant l'intervalle déni par Time
PUB Buttons | Width
‘’COG 1 surveille les 2 boutons-poussoirs pour déterminer la valeur de Ratio
repeat ‘Répète les 8 lignes suivantes indéniment
Width := Ratio
waitpne(%110, %110, 0) ‘Attend qu'un bouton soit appuyé
if ina[1] == 0 ‘Si le bouton Speed UP est appuyé
Width := Width + 1 <# Period ‘alors incrémenter Width jusqu'à Period max
else ‘Bouton Speed DOWN appuyé
Width := Width - 1 #> 0 ‘alors diminuer Width jusqu'à min 0
Ratio := Width
waitcnt(6000 + cnt) ‘Attend avant de contrôler à nouveau les boutons