se faire les dents sur XMOS startKIT

Il y a quelques semaines je présentais le startKIT de XMOS. Depuis j'ai lu pas mal de documentation et cette semaine je me suis fait les dents sur le startKIT en écrivant ma première application. Ça n'a pas été facile de m'adapter aux contraintes du langage XC mais avec de la persévérance j'y suis finalement arrivé.

le jeux de la vie

Le jeux de la vie est un automate cellulaire sur 2 dimensions imaginé par le mathématicien John H. Conway en 1970. Soit une grille ou chaque carré (cellule) peut prendre 2 couleurs, disons noir ou blanc. A chacune des cellules de la grille on applique un ensemble de règles simples et on conserve le nouvel état de la grille et recommence la même opération à partir de ce nouvel état. Lorsque Conway a imaginé cet automate les ordinateurs personnels n'existaient pas encore, chaque itération était calculé à la main et dessiné sur du papier quadrillé. Heureusement on n'en est plus là. C'est beaucoup plus intéressant de confier ce travail à un ordinateur et d'afficher le résultat de chaque itération à l'écran.

J'ai choisi le jeux de la vie pour me faire les dents sur le startKIT car c'est une programmation simple, du moins lorsque c'est écris en 'C' en single thread. Lorsqu'on doit apprendre une nouvelle façon de faire c'est plus difficile comme je l'ai constaté.

La grille est toroïdale et de dimension 36x26. Par toroïdale on entends ceci. Imaginez que l'écran de l'ordinateur est une feuille de papier et qu'on le pli en cylindre pour que le haut vienne touché au bas et qu'ensuite on étire ce cylindre pour que le 2 bouts se touchent. On obtient ainsi une tore et les cellules sont à la surface de cette tore. L'univers ainsi créé est sans rebords mais de surface limité. Ainsi lorsqu'un glider se déplace sur la grille, au lieu de disparaître lorsqu'il arrive à un rebord de l'écran il réapparait de l'autre côté.

Voici un vidéo de la simulation en action. Sur la ligne du bas s'affiche le nombre d'itérations.

Le calcul de chaque itération étant trop rapide j'ai ajouter une délais 0,5 seconde entre chaque itération.

schématique

Code source

/* * Nom: game-of-life.xc * Description: implémentation du jeux de la vie de Conway sur le startKIT. Affichage sur sortie * vidéo NTSC blanc/noir. * La mémoire vidéo est organisée en cellules de caractères. * 36 caractères par ligne et 27 lignes. * La dernière ligne affiche le nombres d'itérations. * Les cellules vivantes sont représenté par un caractère qui a la forme d'un * cercle blanc. * Created on: 2014-01-03 * Auteur: Jacques Deschênes * version: 0.1 */ #include <timer.h> #include <print.h> // pour débogage seulement. #include <stdlib.h> #include <string.h> #include <xs1.h> #include <platform.h> //#include "loup-4g.h" #define LINE_PERIOD (XS1_TIMER_MHZ*1000*1000/15748)// Fhorz=15748Hz #define VIDEO_DLY (100) #define HSYNC (4.7*XS1_TIMER_MHZ) // horizontal sync pulse 4,7µsec #define VSYNC (LINE_PERIOD-2*HSYNC) // vertical sync pulse // déplacement des chiffres et lettres dans la table font #define DIGITS 2 #define LETTERS 13 #define COLUMN 12 const char text[]={ 'I'-'A'+LETTERS, 'T'-'A'+LETTERS, 'E'-'A'+LETTERS, 'R'-'A'+LETTERS, 'A'-'A'+LETTERS, 'T'-'A'+LETTERS, 'I'-'A'+LETTERS, 'O'-'A'+LETTERS, 'N'-'A'+LETTERS, COLUMN, 0 }; const char font[39][8]={ {0,0,0,0,0,0,0,0}, {0x3c,0x7e,0xff,0xff,0xff,0xff,0x7e,0x3c},//rond {0x1c,0x22,0x26,0x2a,0x32,0x22,0x1c,0x00}, // 0 {0x08,0x18,0x08,0x08,0x08,0x08,0x3e,0x00}, // 1 {0x1c,0x22,0x04,0x08,0x10,0x20,0x3e,0x00}, // 2 {0x3c,0x02,0x02,0x3c,0x02,0x02,0x3c,0x00}, // 3 {0x04,0x0c,0x14,0x24,0x3e,0x04,0x04,0x00}, // 4 {0x3e,0x20,0x20,0x3c,0x02,0x02,0x3c,0x00}, // 5 {0x0c,0x10,0x20,0x3c,0x22,0x22,0x1c,0x00}, // 6 {0x3e,0x02,0x04,0x08,0x10,0x10,0x10,0x00}, // 7 {0x1c,0x22,0x22,0x1c,0x22,0x22,0x1c,0x00}, // 8 {0x1c,0x22,0x22,0x1c,0x02,0x02,0x1c,0x00}, // 9 {0x00,0x18,0x18,0x00,0x18,0x18,0x00,0x00}, // : {0x1c,0x22,0x22,0x3e,0x22,0x22,0x22,0x00}, // A {0x3c,0x22,0x22,0x3c,0x22,0x22,0x3c,0x00}, // B {0x1e,0x20,0x20,0x20,0x20,0x20,0x1e,0x00}, // C {0x3c,0x22,0x22,0x22,0x22,0x22,0x3c,0x00}, // D {0x3e,0x20,0x20,0x3e,0x20,0x20,0x3e,0x00}, // E {0x3e,0x20,0x20,0x3e,0x20,0x20,0x20,0x00}, // F {0x1e,0x20,0x20,0x2c,0x22,0x22,0x1c,0x00}, // G {0x22,0x22,0x22,0x3e,0x22,0x22,0x22,0x00}, // H {0x1c,0x08,0x08,0x08,0x08,0x08,0x1c,0x00}, // I {0x1e,0x02,0x02,0x02,0x02,0x24,0x18,0x00}, // J {0x22,0x24,0x28,0x30,0x28,0x24,0x22,0x00}, // K {0x20,0x20,0x20,0x20,0x20,0x20,0x3e,0x00}, // L {0x22,0x36,0x2a,0x22,0x22,0x22,0x22,0x00}, // M {0x22,0x22,0x32,0x2a,0x26,0x22,0x22,0x00}, // N {0x1c,0x22,0x22,0x22,0x22,0x22,0x1c,0x00}, // O {0x3c,0x22,0x22,0x3c,0x20,0x20,0x20,0x00}, // P {0x1c,0x22,0x22,0x22,0x2a,0x26,0x1e,0x00}, // Q {0x3c,0x22,0x22,0x3c,0x28,0x24,0x22,0x00}, // R {0x1e,0x20,0x20,0x1c,0x02,0x02,0x3c,0x00}, // S {0x3e,0x08,0x08,0x08,0x08,0x08,0x08,0x00}, // T {0x22,0x22,0x22,0x22,0x22,0x22,0x1c,0x00}, // U {0x22,0x22,0x22,0x22,0x22,0x14,0x08,0x00}, // V {0x22,0x22,0x22,0x2a,0x2a,0x36,0x22,0x00}, // W {0x22,0x22,0x14,0x08,0x14,0x22,0x22,0x00}, // X {0x22,0x22,0x22,0x14,0x08,0x08,0x08,0x00}, // Y {0x3e,0x04,0x08,0x10,0x20,0x20,0x3e,0x00}, // Z }; // dimension mémoire vidéo #define BUFF_WIDTH 36 // octets par lignes #define BUFF_HEIGHT 27 // nombre de ligne de caractères #define COPY_SIZE (BUFF_WIDTH*BUFF_HEIGHT) unsigned char video_buffer[BUFF_HEIGHT][BUFF_WIDTH]; // mémoire viédo unsigned char life_buffer[2][BUFF_HEIGHT][BUFF_WIDTH]; // tableau double pour jeux de la vie. interface cells_array{ void CopyCellArray(char p[], const int size); }; //REF: http://en.wikibooks.org/wiki/C_Programming/C_Reference/stdlib.h/itoa /* reverse: reverse string s in place */ void reverse(char s[]) { int i, j; char c; for (i = 0, j = strlen(s)-1; i<j; i++, j--) { c = s[i]; s[i] = s[j]; s[j] = c; } }//f() //REF: http://en.wikibooks.org/wiki/C_Programming/C_Reference/stdlib.h/itoa /* itoa: convert n to characters in s */ void itoa(int n, char s[]) { int i, sign; if ((sign = n) < 0) /* record sign */ n = -n; /* make n positive */ i = 0; do { /* generate digits in reverse order */ s[i++] = n % 10 + '0'; /* get next digit */ } while ((n /= 10) > 0); /* delete it */ if (sign < 0) s[i++] = '-'; s[i] = '\0'; reverse(s); }//f() void PrintStepCount(int count,char t){// imprime le nombre d'itérations int x; char digits[10]; x=strlen(text)+1; itoa(count,digits); for (int i=0;digits[i];i++){ life_buffer[t][26][x]=digits[i]-'0'+DIGITS; x++; } }//f() void ntsc_video(out port sync_port, out port blvl_port, out port video_port, server interface cells_array cells){ int pwm_cycle, line_cntr, sync_end, video_delay; unsigned int video_data; line_cntr=0; // scan lines counter sync_port <: 0 @ pwm_cycle; while(1){ line_cntr++; if (line_cntr==262){ line_cntr=0; } if (line_cntr < 4){ sync_end = pwm_cycle + VSYNC; }else{ sync_end = pwm_cycle + HSYNC; } sync_port @ sync_end <: 1; if (line_cntr>30 && line_cntr<247){ video_delay = sync_end+HSYNC; blvl_port @ video_delay <: 1; video_delay += VIDEO_DLY; for (int x=0;x<BUFF_WIDTH;x++){ video_data=font[video_buffer[(line_cntr-31)/8][x]][(line_cntr-31)%8]; for (int b=7;b>-1;b--){ video_port @ video_delay <: (video_data &(1<<b))>>b; video_delay += 18; } }//for video_port <: 0; }else{//if select{ case cells.CopyCellArray(char p[],const int size): memcpy(video_buffer,p,sizeof(char)*size); break; default: break; }//select } video_delay = pwm_cycle+LINE_PERIOD-100; blvl_port @ video_delay <: 0; pwm_cycle += LINE_PERIOD; sync_port @ pwm_cycle <: 0 ; }//while }//f() char GetCell(int t, int y, int x){ return life_buffer[t][y][x]; }//f() void WriteCell(int t, int y, int x, char cell){ life_buffer[t][y][x] = cell; }//f() void next_gen(client interface cells_array ca){ int count,x,y,yu,yd,xl,xr, step=0; char toggle=0; char cell; timer t; int now; ca.CopyCellArray((char *)life_buffer[toggle],COPY_SIZE); t :> now; while(1){ now += XS1_TIMER_MHZ*1000*500; PrintStepCount(step,toggle); t when timerafter(now) :> void; for(y=0;y<BUFF_HEIGHT-1;y++){ for(x=0;x<BUFF_WIDTH;x++){ cell=GetCell(toggle,y,x); count=0; if (x>0) xl = x-1; else xl=BUFF_WIDTH-1; if (x<BUFF_WIDTH-1) xr= x+1; else xr = 0; if (y>0) yu = y-1; else yu=BUFF_HEIGHT-2; if (y<BUFF_HEIGHT-2) yd = y+1;else yd=0; count += GetCell(toggle,yu,xl); count += GetCell(toggle,yu,x); count += GetCell(toggle,yu,xr); count += GetCell(toggle,y,xl); count += GetCell(toggle,y,xr); count += GetCell(toggle,yd,xl); count += GetCell(toggle,yd,x); count += GetCell(toggle,yd,xr); switch (count){ case 2: break; case 3: cell=1; break; default: cell=0; } WriteCell((~toggle)&1,y,x,cell); }//for }//for toggle=(~toggle)&1; ca.CopyCellArray((char *)life_buffer[toggle],COPY_SIZE); step++; }//while }//f() //Port definitions out port ntsc_sync_port = XS1_PORT_1G; // J7-3, X0D22 out port ntsc_blvl_port = XS1_PORT_1H; // J7-2, X0D23 out port ntsc_video_port = XS1_PORT_1F; // J7-1 , X0D13 clock clk = XS1_CLKBLK_1; int main(void){ timer t; int time; t :> time; srand(time); int y,x; for (x=0;x<strlen(text);x++){ life_buffer[0][26][x]=text[x]; life_buffer[1][26][x]=text[x]; } // initialisation de la grille au hasard for (y=0;y<BUFF_HEIGHT-1;y++){ for(x=0;x<BUFF_WIDTH;x++){ life_buffer[0][y][x]= rand()&1; } } ntsc_sync_port <: 1; ntsc_blvl_port <: 0; ntsc_video_port <: 0; interface cells_array ca; par { ntsc_video(ntsc_sync_port,ntsc_blvl_port,ntsc_video_port,ca); next_gen(ca); } return 0; }

Description

Le tableau video_buffer est la mémoire vidéo qui contient l'information à afficher à l'écran. Cette mémoire contient les indices des caractères dans la table font. life_buffer contient l'état de l'univers de l'automate cellulaire. Ce tableau est double car lors du calcul d'une itération la version originale ne peut-être modifiée. On écris donc le résultat dans l'autre moitié et on alterne entre les deux moitiés à chaque itération.

Dans la procédure principale on initialise la grille life_buffer en utilisant le générateur pseudo-hasard rand(). La variable timer t n'est utilisée que pour initialiser le générateur pseudo-hasard.

Le générateur de signal NTSC utilise 3 ports de 1 bit, ntsc_sync_port génère le signal de synchronisation. ntsc_blvl_port détermine le niveau noir et finalement ntsc_video_port est la sortie des pixels vidéo.

interface

Dans le langage XC une interface permet de définir un canal de communication entre 2 threads. Dans ce programme il y a 2 threads next_gen et ntsc_video. Chacun de ces threads s'exécute sur un core différent. Comme la variable video_buffer et contrôlée par le thread ntsc_video le thread next_gen ne peut y accéder. Donc lorsque next_gen a terminé le calcul d'une itération il envoie le nouveau tableau au thread ntsc_video par l'interface cells_array. Cette interface ne contient qu'une seule fonction CopyCellArray(). le nouveau tableau est copié dans video_buffer pendant le vertical retrace donc il n'y a pas de glitches dans l'affichage.

Dans la fonction ntsc_video() il y a un select. Les select en XC servent à écouter un canal de communication en attente d'information. Pour chaque fonction de l'interface il doit y avoir un case correspondant dans le select. Chaque case doit-être terminé par un break ou un return. Pour éviter que le thread ne bloque sur l'attente du message fournis par CopyCellArray() on utilise un

default:break;

. Le default permet de sortie du select et continuer l'exécution du thread. S'il n'y avait pas de cette option le générateur NTSC ne fonctionnerais pas.

Une interface est un canal client/serveur. C'est à dire qu'un des thread est le serveur c'est à dire celui qui attends les requêtes distribuées via les fonctions de l'interface. Le client lui évidemment envoie les requêtes.

Dans la fonction main(),

interface cells_array ca;

déclare une variable d'interface ca qui est passé en arguments aux 2 threads qui utilisent cette interface. Notez comment le paramètre d'interface est déclaré dans chaque thread. client pour next_gen() et server pour ntsc_video().

void next_gen(client interface cells_array ca) 

void ntsc_video(out port sync_port,
                out port blvl_port,
                out port video_port,
                server interface cells_array cells) 

Les interfaces sont des canaux de communications point à point donc la variable ca ne peut-être passée en argument qu'à un seul thread client et un seul thread server. Si un serveur a plusieurs clients il faut déclarer une variable différente pour chaque client. l'ensemble de ces variables peut-être gardé dans un tableau qui est passé en argument au serveur.

Conclusion

Bien que de se familiariser avec une nouvelle technologie demande des efforts le succès est toujours gratifiant. La version 0.2 de ce programme pourrait utiliser les 2 règles tactiles et le bouton qui sont sur la carte startKIT pour créer une interface utilisateur servant à initialiser la grille au lieu de le faire avec une fonction au hasard. A suivre.

---

Mise à jour 2014-01-18

game of life version 0.2

• Initialisation manuelle de la grille en utilisant le bouton, slider x, slider y qui sont sur la carte startKIT.
• augmentation du nombre de cellules, grille de 176x110.

Au démarrage le mot INITIALISATION apparaît au bas de l'écran et un pixel clignote au centre (curseur). En utilisant les 2 slider on déplace le curseur sur la grille. A l'endroit désiré on presse le bouton pour mettre une cellule à cette endroit. S'il y a déjà une cellule elle est effacée (inverse l'état sous le curseur). Pour sortir de l'initialisation il faut garder le bouton enfoncé 2 secondes.

Dans ce vidéo la configuration initiale est un U constitué de 7 cellules comme indiqué sur la page jeux_de_la_vie sur wikipekdia. On aperçoit donc la face de clown à l'itération 110.

Code source

`

J'ai réorganisé le code source en plusieurs fichiers, de plus ce programme utilise 2 modules fournis par XMOS, module_startkit_gpio et module_capacitive_sensing

Le projet peut-être téléchargé ici.

Difficulté avec l'IDE

Lorsqu'on utilise des modules dans un projet il ne suffit pas de les référencés dans les propriétés du projet comme ici.

Ça ne suffit pas pour que le compilateur/lieur trouve le code source. Il faut indiquer les modules dans le Makefile.

Dans le project explorer on double-clique sur le Makefile pour ouvrir une fenêtre de configuration du Makefile.

Dans le groupe Used Modules on coche les modules utilisés par le projet.

J'ai du chercher avant de trouver la solution. Si on référence un module dans les propriétés du projet il me semble que l'IDE devrait configuré le Makefile en conséquence.

---

Si les automates cellulaires vous intéressent Golly est un excellent logiciel de simulation multiplateforme. Il ne simule pas seulement le jeux de la vie mais de nombreux autres types d'automates 1D ou 2D. Vous pouvez-même créer vos propres règles. Il y a de nombreux exemples de configurations qui donnent des animations intéressantes.