surprise et perplexité.

J'étais en train d'écrire une routine de division en assembleur sur PIC32MX lorsque j'ai réalisé que le core MIPS M4K n'a pas de registre d'état. Ça fait des mois que je travaille avec des PIC32MX et jusque là je n'avais pas porté attention à ce fait. En réalité c'est le seul processeur que je connais qui n'en possède pas et j'en ai vu pas mal ces 40 dernières années. Comme cette routine de division utilise un décalage vers la gauche sur 2 mots de 32 bits j'étais un peut perplexe. En effet habituellement lorsqu'on fait un décalage à gauche ou à droite sur plusieurs mots on utilise une instruction qui récupère le bit qui sort dans le carry bit et de là on le récupère pour le faire entrer dans le mot suivant. C'est du moins comme ça que ça se passe sur la majorité des micro-processeurs. J'ai donc du adapter ma routine en vérifiant l'état du bit avant de faire le décalage et faire un branchement conditionnel en fonction de l'état de ce bit. La routine nécessite donc plus d'instructions que sur un processeur ARM par exemple qui laisse le dernier bit sorti dans carry bit du registre d'état.

# division non signée d'un double précision par un simple, retourne quotient et reste # si le quotient > 32 bits retourne -1 -1. umsmod: # 'UM/MOD (ud1 u1 -- u2 u3|-1 -1) u2=reste, u3=quotient lw t0, -CELL_SIZE(dp) # 32 bits poids faible lw t1, 0(dp) # 32 bits poids fort bgtz t1, long_div nop divu t0, T mfhi t0 # reste mflo T # quotient sw t0, -CELL_SIZE(dp) b next addiu dp, dp, -CELL_SIZE 1: li T, -1 # quotient > 32 bits sw T, -CELL_SIZE(dp) b next addiu dp,dp,-CELL_SIZE long_div: divu t1,T mflo t3 #quotient bgtz t3, 1b mfhi t1 #reste li t2, 32 # compteur de boucle 2: bltz t3, 1b # overflow sll t3,t3,1 subu t4,t1,T bltz t4,3f nop move t1, t4 ori t3,t3,1 3: addiu t2,t2,-1 # décrémente le compteur de boucle beqz t2, 5f # division terminée si 0 nop sll t1,t1,1 # décale à gauche t1:t0 bgez t0, 4f # on vérifie si le bit le plus signification est à 1 nop # si ce n'est pas le cas on saute l'instruction suivante ori t1,t1,1 # transfert du bit dans t1 4: b 2b sll t0,t0,1 5: move T, t3 # quotient sw t1, -CELL_SIZE(dp) # reste b next addiu dp,dp,-CELL_SIZE

C'est encore une preuve que les habitudes nous rendent aveugle. Ce n'est pas que je n'avais pas étudier le modèle de programmation du core M4K mais je prenais pour acquis que tout processeur à un registre d'état ce qui fait que cette absence n'était pas passé au niveau conscient puisqu'il n'avais pas été requis dans ma programmation jusque là.

présentation des PIC24

Dans cette article je fais une brève présentation des micro-contrôleurs PIC24 de Microchip.

Architecture

Comme les autres PIC les PIC24 sont basés sur une architecture Harvard mais là s'arrête la ressemblance. Il s'agit de micro-contrôleurs 16 bits avec 16 registres généraux. Ils possèdent un multiplicateur en hardware ainsi qu'un support à la division.

Structure interne

Le compteur ordinal a 23 bits. Les instructions son encodées sur 24 bits et le compteur peut adresser 4Mi. Notez cependant que le bit le plus faible du compteur ordinal est toujours à zéro, les adresses impaires ne peuvent-être accédées. La mémoire est organisé en mots de 24 bits mais l'alignement du compteur ordinal se fait comme s'il s'agissait de 2 mots de 16 bits. Donc dans les faits le compteur ordinal est incrémenté de 2 à chaque instruction. Il n'y a pas d'octets perdus cependant car l'octet le plus lourd (bits 24-32) n'est pas implémenté en mémoire. Cette arrangement est pour rendre comptable l'adressage avec la mémoire RAM qui elle est organisée en mots de 16 bits.

Les registres généraux sont nommés W0 à W15. W15 sert de pointeur de pile, celle-ci étant en mémoire RAM. IL y a un registre SPLIM qui détermine la taille de la pile. S'il y a débordement de la pile l'exception 3 stack error est déclenchée. Notez la présence du registre RCOUNT, c'est un compteur de boucle qui fonctionne avec l'instruction assembleur REPEAT. Cette instruction utilisée avec les instructions DIV.SD, DIV.SW, DIV.UD et DIV.UW permet de faire une division en seulement 19 cycles machine. Les boucles REPEAT sont limitées à une seule instruction, celle qui suis le REPEAT. Mais comme l'instruction MOV encode la source et la destination par indirection via registre auto-incrémenté, une seule instruction permet de copier un bloc de mémoire d'un endroit à un autre ou vers un SFR de périphérique.

Contrairement à la plupart des MCU à registres comme les AVR, MIPS ou MSP430, les PIC24 peuvent utiliser une donnée en mémoire RAM comme argument d'une opération ALU, dans ce cas W0 alias WREG est utilisé comme autre argument. Le résultat peut-être enregistré dans WREG ou la variable en RAM. Ce type d'instruction même s'il exige une lecture et possiblement une écriture dans la RAM s'exécute en un seul cycle. Comme pour les PIC32MX les instructions à 3 arguments sont aussi possible comme ADD Wb,Ws,Wd qui additionne le contenu de Wb avec Ws et met le résultat dans Wd.

Interruptions

Les interruptions multi-niveaux sont supportées. Il y a 2 tables de vecteurs d'interruptions contenant chacune 126 entrée. Les 8 premières entrées sont réservés aux exceptions (trap). Ces tables commencent à l'adresse 0x000004 et se terminent à l'adresse 0x000200. L'interruption 0 est à l'adresse 0x14 pour la table principale et 0x114 pour la table alternative. Chaque table occupe 256 octets incluant les trap et le reset vector. La table alternative sert au débogage. Chaque entrée de table contient une adresse de 24 bits qui est le point d'entrée de l'ISR servant le vecteur correspondant. La priorité d'interruption est par ordre inverse du numéro de vecteur. Le vecteur 0 a la plus haute priorité et le 117 la plus faible.

Modèle de programmation

Programme démo en C

Plusieurs modèles de PIC24 sont disponibles en format PDIP-14, PDIP-20 et PDIP-28. Pour ce démo j'ai choisi un PIC24F16KA101-I/P ainsi qu'une matrice de LED 8x8. La matrice de LEDs est organisée en 8 lignes par 8 colonnes. Les cathodes sont connectées sur les colonnes et les anodes sur les lignes. Le PIC24F16KA101 possède 16Ko de mémoire flash et 1,5Ko de RAM et les périphériques qu'on retrouve le plus souvent sur un MCU, minuteries, convertisseur A/N, UART, I2C. Il fonctionne à une fréquence maximale de 32Mhz. Il peut-être programmé avec un PICKIT 2.

L'environnement de développement est MPLABX avec le compilateur XC16 disponible en version gratuite avec optimisation de code limité comme c'est l'habitude chez Microchip.

Le démo est une implémentation de l'automate cellulaire appelé Jeux de la vie. Le démo joue 3 configurations en séquence. Il passe à la configuration suivante après 16 générations. C'est la variable max_gen qui détermine le nombre de générations calculées pour chaque configuration initiale.

schématique

La grille de LED est multiplexé 1 LED à la fois. Le rapport cyclique de chaque LED est donc de 1/64 on obtient néanmoins une intensité d'affichage satisfaisante. Pour ne pas interrompre le multiplexeur d'affichage le calcul de la génération suivante est intercalé dans le multiplexeur par appel de la fonction next_gen(). Une seule cellule est recalculée par appel. Il y a 2 tableaux contenant l'état de l'univers, lifea et lifeb. Tandis qu'un tableau est affiché le calcul de la génération suivante est enregistré dans l'autre. La variable grid détermine quel est le tableau à afficher. Le tableau est commuté à tous les 100 cycles du multiplexeur d'affichage (variable k dans display_grid()). Ce délais donne un peu plus 0,5 seconde entre chaque commutation.

Pour la Configuration bits settings j'ai procédé comme je le fais avec les PIC32MX. C'est à dire que j'utilise le menu Window - PIC memory views - configuration bits. Après avoir configuré les bits dans cette grille j'utilise le bouton generate source code to Output et ensuite un copier-coller vers mon fichier source.

Pour ce démo le MCU fonctionne à 8Mhz sur l'oscillateur interne mais cette fréquence peut-être augmentée à 32Mhz grâce au PLL inclus dans le MCU.

Code source du démo

/* * File: led-matrix.c * Author: jacques Deschênes * Description: programme démo sur PIC24F16KA101. John Conway's game of life sur * matrice de LED 8x8. * Created on 28 novembre 2013, 13:34 */ #include <stdio.h> #include <stdlib.h> #include <p24F16KA101.h> // PIC24F16KA101 Configuration Bit Settings #include <xc.h> // FBS #pragma config BWRP = OFF // Table Write Protect Boot (Boot segment may be written) #pragma config BSS = OFF // Boot segment Protect (No boot program Flash segment) // FGS #pragma config GWRP = OFF // General Segment Code Flash Write Protection bit (General segment may be written) #pragma config GCP = OFF // General Segment Code Flash Code Protection bit (No protection) // FOSCSEL #pragma config FNOSC = FRCDIV // Oscillator Select (8 MHz FRC oscillator with divide-by-N (FRCDIV)) #pragma config IESO = OFF // Internal External Switch Over bit (Internal External Switchover mode disabled (Two-Speed Start-up disabled)) // FOSC #pragma config POSCMOD = NONE // Primary Oscillator Configuration bits (Primary oscillator disabled) #pragma config OSCIOFNC = ON // CLKO Enable Configuration bit (CLKO output disabled; pin functions as port I/O) #pragma config POSCFREQ = HS // Primary Oscillator Frequency Range Configuration bits (Primary oscillator/external clock input frequency greater than 8 MHz) #pragma config SOSCSEL = SOSCLP // SOSC Power Selection Configuration bits (Secondary oscillator configured for low-power operation) #pragma config FCKSM = CSDCMD // Clock Switching and Monitor Selection (Both Clock Switching and Fail-safe Clock Monitor are disabled) // FWDT #pragma config WDTPS = PS32768 // Watchdog Timer Postscale Select bits (1:32,768) #pragma config FWPSA = PR128 // WDT Prescaler (WDT prescaler ratio of 1:128) #pragma config WINDIS = ON // Windowed Watchdog Timer Disable bit (Windowed WDT enabled) #pragma config FWDTEN = OFF // Watchdog Timer Enable bit (WDT disabled (control is placed on the SWDTEN bit)) // FPOR #pragma config BOREN = BOR3 // Brown-out Reset Enable bits (Brown-out Reset enabled in hardware; SBOREN bit disabled) #pragma config PWRTEN = ON // Power-up Timer Enable bit (PWRT enabled) #pragma config I2C1SEL = PRI // Alternate I2C1 Pin Mapping bit (Default location for SCL1/SDA1 pins) #pragma config BORV = V18 // Brown-out Reset Voltage bits (Brown-out Reset set to lowest voltage (1.8V)) #pragma config MCLRE = ON // MCLR Pin Enable bit (MCLR pin enabled; RA5 input pin disabled) // FICD #pragma config ICS = PGx2 // ICD Pin Placement Select bits (PGC2/PGD2 are used for programming and debugging the device) // FDS #pragma config DSWDTPS = DSWDTPSF // Deep Sleep Watchdog Timer Postscale Select bits (1:2,147,483,648 (25.7 Days)) #pragma config DSWDTOSC = LPRC // DSWDT Reference Clock Select bit (DSWDT uses LPRC as reference clock) #pragma config RTCOSC = LPRC // RTCC Reference Clock Select bit (RTCC uses LPRC as reference clock) #pragma config DSBOREN = ON // Deep Sleep Zero-Power BOR Enable bit (Deep Sleep BOR enabled in Deep Sleep) #pragma config DSWDTEN = OFF // Deep Sleep Watchdog Timer Enable bit (DSWDT disabled) // broches des cathodes (colonnes) tous sur PORTB #define C1 1 #define C2 2 #define C3 4 #define C4 16 #define C5 (1<<7) #define C6 (1<<8) #define C7 (1<<9) #define C8 (1<<12) // broches des anodes (lignes ) A1..A5 sur PORTA, A6..A8 sur PORTB #define A1 1 #define A2 2 #define A3 8 #define A4 16 #define A5 (1<<6) #define A6 (1<<13) #define A7 (1<<14) #define A8 (1<<15) const int cathode[8]={C1,C2,C3,C4,C5,C6,C7,C8}; const int anode[8]={A1,A2,A3,A4,A5,A6,A7,A8}; char lifea[10][10]; char lifeb[10][10]; char grid; void init_mcu(){ TRISA=0; // toutes les broches de PORTA sont des sorties TRISB=0; // toutes les broches de PORTB sont en sorties }//init_mcu() void init_grid(char pattern){ int l,c; for(l=0;l<10;l++) for(c=0;c<10;c++) lifea[l][c]=0; switch (pattern){ case 0:// glider lifea[3][1]=1; lifea[3][2]=1; lifea[3][3]=1; lifea[2][3]=1; lifea[1][2]=1; break; case 1: lifea[4][3]=1; lifea[4][4]=1; lifea[4][5]=1; lifea[3][4]=1; break; case 2: // octagon lifea[1][4]=1; lifea[1][5]=1; lifea[2][3]=1; lifea[2][6]=1; lifea[3][2]=1; lifea[3][7]=1; lifea[4][1]=1; lifea[4][8]=1; lifea[5][1]=1; lifea[5][8]=1; lifea[6][2]=1; lifea[6][7]=1; lifea[7][3]=1; lifea[7][6]=1; lifea[8][4]=1; lifea[8][5]=1; break; } //lifea[5][4]=(char)1; grid=0; }//init_grid() void next_gen(int c, int l){ int cnt; if (grid){ cnt=lifeb[l-1][c-1]+lifeb[l-1][c]+lifeb[l-1][c+1]+ lifeb[l][c-1]+lifeb[l][c+1]+ lifeb[l+1][c-1]+lifeb[l+1][c]+lifeb[l+1][c+1]; if ((lifeb[l][c] && cnt>=2 && cnt<=3)|| (!lifeb[l][c] && cnt==3)) lifea[l][c]=1; else lifea[l][c]=0; }else{ cnt=lifea[l-1][c-1]+lifea[l-1][c]+lifea[l-1][c+1]+ lifea[l][c-1]+lifea[l][c+1]+ lifea[l+1][c-1]+lifea[l+1][c]+lifea[l+1][c+1]; if ((lifea[l][c] && cnt>=2 && cnt<=3)|| (!lifea[l][c] && cnt==3)) lifeb[l][c]=1; else lifeb[l][c]=0; } } // next_gen; void display_grid(int max_gen){ int l, c; unsigned int k; char n; k=100; while(max_gen){ for(l=0;l<8;l++){ for(c=0;c<8;c++){ LATB=C1|C2|C3|C4|C5|C6|C7|C8; LATA=0; if (grid) n=lifeb[l+1][c+1]; else n=lifea[l+1][c+1]; if (n){ LATB &= ~cathode[c]; if (l<5){ LATA=anode[l]; }else{ LATB|=anode[l]; } } next_gen(c+1,l+1); }//for(c... }//for(l... if (!(--k)){ grid=~grid; k=100; max_gen--; } }//while(1) }//display_grid() /* * */ void main(void) { int pattern; init_mcu(); pattern=0; while(1){ init_grid(pattern); display_grid(16); pattern++; pattern %=3; } }

Vidéo du démo

Conclusion

Dans un prochain article je vais présenter un démo en assembleur.

moteur pas à pas

Dans cette article j'explique comment contrôler un moteur pas à pas . Pour ce démo j'ai utilisé un MSP430 launchpad et un C.I. L293D pour piloter le moteur. Comme moteur j'ai utilisé le mécanisme de transport de la tête de lecture d'un graveur de CD. On retrouve aussi le même type de mécanisme dans les lecteurs de disquettes.

schématique

Le moteur a 2 bobines et comme illustré ci-haut. Il s'agit d'un moteur bipolaire il y a donc 4 connections au moteur. Sur les moteurs unipolaire il y a en 6.

Description

En fait le programme pour contrôler un moteur pas à pas est simple. On a besoin d'un pont H pour chaque bobine et c'est le L293D qui contient 4 demi-pont H qui est utilisé dans ce but. Lorsqu'on alimente une bobine le rotor s'aligne sur le champ magnétique créé par la bobine. Si on alimente les 2 bobines en même temps le champ magnétique résultant est entre les 2 bobines et le rotor s'aligne donc entre celle-ci. Donc pour déplacé le rotor on déplace le champ magnétique du stator en alimentant alternativement les bobines.

Il y a plusieurs façon d'alimenter un moteur pas à pas mais celle qui donne le plus petit angle de rotation à chaque pas est la suivante:

pas	a1	b1	a2	b2
1	+5v	0v	0v	0v
2	+5v	+5v	0v	0v
3	0v	+5v	0v	0v
4	0v	+5v	+5v	0v
5	0v	0v	+5v	0v
6	0v	0v	+5v	+5v
7	0v	0v	0v	+5v
8	+5v	0v	0v	+5v

Pour faire tourner le moteur en continu dans un direction il suffit de répéter ces 8 pas en boucle et pour le faire tourner dans l'autre sens on les répète à l'envers c'est à dire de 8 à 1. J'ai branché les 4 fils des bobinages sur le même port (PORT1) de sorte qu'il suffit de conserver les valeurs pour chaque pas dans un tableau indicé par la phase. Il faut écrire la valeur correspondant à la phase ou le moteur est rendu dans P1OUT. La valeur de chaque nombre dans le tableau correspond aux étapes de cette table.

Un moteur pas à pas il n'y a pas de rétroaction comme pour le cerveau moteur donc on ne connaît pas la position du moteur. Il faut compter les pas et habituellement on utilise des commutateurs en fin de course pour indiquer que la limite est atteinte. Mais si la charge est trop grande et que le moteur glisse le compteur de pas n'est plus valide il faut voir à ce que la charge ne dépasse pas la capacité du moteur. Il faut aussi tenir compte de l'inertie. Plus la charge est grande plus le moteur va prendre de temps pour s'aligner sur la nouvelle position. Donc le délais de pas doit-être augmenter avec la charge. Comme au départ je ne connaissait pas les caractéristiques du moteur j'ai commencer les tests avec un délais long (50msec), pour le réduire progressivement jusqu'à 1msec. Mais à 1 msec le moteur vibre. A 2msec c'est parfais. Mais si je mettais une charge sur le chariot il faudrait probablement augmenter ce délais.

Pour ce démo j'ai simplement vérifier à quelle vitesse je pouvais déplacer le chariot de tête du graveur en envoyant 200 impulsions dans un sens et ensuite 200 dans l'autre. /* * NOM: phase-motor-ctrl.c * DESCRIPTION: démonstration du contrôle d'un moteur pas à pas. * Il s'agit d'un moteur bipolaire (4 fils) * AUTEUR: Jacques Deschênes * DATE: 2013-11-23 * */ #include <msp430.h> // bit du PORT 1 utilisés pour contrôler le moteur pas à pas #define PHA1 BIT1 // bobine A fil 1 #define PHB1 BIT2 // bobine B fil 2 #define PHA2 BIT3 // bobine A fil 2 #define PHB2 BIT4 // bobine B fil 1 #define ENABLE BIT0 #define phase_dly 2 // délais qui contrôle la vitesse déplacement void delay_ms(unsigned int msec){ while (msec--) __delay_cycles(1000); }// delay_ms() #define NUM_PHASES 8 unsigned char phase; const char phase_seq[NUM_PHASES]={2,6,4,12,8,24,16,18}; void one_step(char dir){ // dir > {0,1} if (dir) phase = (++phase) % NUM_PHASES; else phase = (--phase) % NUM_PHASES; P1OUT = phase_seq[phase]|ENABLE; delay_ms(phase_dly); }//one_step() /* * main.c */ int main(void) { WDTCTL = WDTPW | WDTHOLD; // Stop watchdog timer P1DIR = ENABLE|PHA1|PHB1|PHA2|PHB2; P1OUT =0; phase= 0; int i; while (1){ for(i=200;i;i--){ one_step(1); } for(i=200;i;i--){ one_step(0); } } return 0; }

déplacement lent, 50msec/pas déplacement rapide 2msec/pas.

Conclusion

Comme on le voie un pilote de moteur pas à pas c'est simple. Il serait facile d'adapter ça en assembleur pour n'importe quel microcontrôleur.