msp430 launchpad, partie 8

Mise à jour 2013-07-27

Continuant mes expérimentations avec la génération d'un signal NTSC j'ai appris¹ qu'il est possible de simplifier la synchronisation. Premièrement il n'est pas nécessaire de générer des lignes de demi-longueur (9 au total) 3 pulses larges, 3 pulses étroits et 3 pulses larges pour assurer la synchronisation verticale. Il suffit de générer 3 lignes avec des pulses larges (H_LINE-H_SYNC) à toute les 262 lignes. De plus au lieu de compter 262,5 lignes on peut en compter 262. Ça fonctionne tout aussi bien avec cette simplification. Voici le code de ta1_ccr0_isr simplifié. #pragma vector=TIMER1_A0_VECTOR __interrupt void ta1_ccr0_isr(void){ // synchronisation NTSC ln_cnt++; switch (ln_cnt){ case 4: TA1CCR1=H_SYNC; break; case FIRST_LINE: // première avec affichage display=1; break; case LAST_LINE: // dernière ligne avec affichage display=0; break; case 262: ln_cnt=1; TA1CCR1=H_LINE-H_SYNC; break; default:; } } // ta1_ccr0_isr() J'ai aussi modifié les constantes suivantes:
#define FIRST_LINE 30 // première ligne avec affichage
#define LAST_LINE 250 // dernière ligne avec affichage

NOTE 1) référence: Programming 32 bits microcontrollers in C, Exploring PIC32, Lucio Di Jasio, Éd. Newnes.
chapitre 13 page 339.

Génération d'un signal NTSC

Ces derniers jours j'ai expérimenter avec la génération d'un signal vidéo NTSC en noir et blanc sur le launchpad avec le processeur G2553. Le programme démo est entièrement en 'C', pas une seule ligne de code assembleur et ça fonctionne. Générer un signal NTSC sur un petit microcontrôleur est grandement simplifié grâce à la technique du progressive scan et à utilisation judicieuse de 2 périphériques, soit une minuterie en mode PWM pour générer le signal de synchronisation et d'un périphérique SPI pour la sortie du signal vidéo. Quand au circuit électronique il est des plus simple puisqu'il ne nécessite que 2 résistances. Je vais expliquer en détail comment ça fonctionne.

Code source

/* * 2013-07-14 * auteur: Jacques Deschênes * description: démo de génération d'un signal NTSC noir et blanc en progressive scan. * le circuit vidéo est très simple il suffit de 2 résisistances: * P2.1---470R---+ * |--- vidéo vers entrée NSTC du téléviseur. * P1.7---220R---+ * l'entrée NTSC du téléviseur a un résistance de 75 ohm et les valeurs des résistances * sont calculées en fonction de cettte valeur. * * périphériques utilisés: * TIMER_A1 pour la synchronisation vidéo * UCB0 en mode SPI pour la sortie vidéo. * * REF: https://github.com/adammholmes/mspvideo * REF: TI document slaa177 * REF: http://www.43oh.com/forum/viewtopic.php?f=9&t=1203 * REF: https://github.com/Always8bit/NTSCPong_MSP430G2553 * REF: http://naturetm.com/?p=47 * REF: http://www.ntsc-tv.com/ntsc-index-02.htm */ #include <msp430.h> #include <string.h> #define H_LINE 1000 // 62,5µSec #define H_HALF_LINE 500 // 31,2µSec #define H_NARROW_SYNC 75 // normalement devrait-être 38 mais ça fonctionne aussi bien avec cette valeur #define H_SYNC 75 // 4,7µSec #define H_DISPLAY_DELAY 140 #define FIRST_LINE 38 // première ligne avec affichage #define LAST_LINE 262 // dernière ligne avec affichage #define SYNC_OUT BIT1 #define VIDEO_OUT BIT7 volatile unsigned int ln_cnt; // compte les ligne balyage NTSC volatile unsigned char display; // indicateur booléen activant l'ISR d'affichage. // police de caractères 5x7 lettres majuscules et chiffre const unsigned char font[][7]={ {0x00,0x00,0x00,0x00,0x00,0x00,0x00}, // espace {0x04,0x04,0x04,0x04,0x04,0x00,0x04}, // ! {0x0a,0x0a,0x0a,0x00,0x00,0x00,0x00}, // " {0x0a,0x0a,0x1f,0x0a,0x1f,0x0a,0x0a}, // # {0x04,0x0f,0x14,0x0e,0x05,0x1e,0x04}, // $ {0x18,0x19,0x02,0x04,0x08,0x13,0x03}, // % {0x0c,0x12,0x14,0x08,0x15,0x12,0x0d}, // & {0x0c,0x04,0x08,0x00,0x00,0x00,0x00}, // ' {0x02,0x04,0x08,0x08,0x08,0x04,0x02}, // ( {0x08,0x04,0x02,0x02,0x02,0x04,0x08}, // ) {0x00,0x04,0x15,0x0e,0x15,0x04,0x00}, // * {0x00,0x04,0x04,0x1f,0x04,0x04,0x00}, // + {0x00,0x00,0x00,0x00,0x0c,0x04,0x08}, // , {0x00,0x00,0x00,0x1e,0x00,0x00,0x00}, // - {0x00,0x00,0x00,0x00,0x00,0x0c,0x0c}, // . {0x00,0x01,0x02,0x04,0x08,0x10,0x00}, // / {0x0e,0x11,0x13,0x15,0x19,0x11,0x0e}, // 0 {0x04,0x0c,0x04,0x04,0x04,0x04,0x1f}, // 1 {0x0e,0x11,0x02,0x04,0x08,0x10,0x1f}, // 2 {0x1e,0x01,0x01,0x1e,0x01,0x01,0x1e}, // 3 {0x02,0x06,0x0a,0x12,0x1f,0x02,0x02}, // 4 {0x1f,0x10,0x10,0x1e,0x01,0x01,0x1e}, // 5 {0x06,0x08,0x10,0x1e,0x11,0x11,0x0e}, // 6 {0x1f,0x01,0x02,0x04,0x08,0x08,0x08}, // 7 {0x0e,0x11,0x11,0x0e,0x11,0x11,0x0e}, // 8 {0x0e,0x11,0x11,0x0e,0x01,0x01,0x0e}, // 9 {0x00,0x0c,0x0c,0x00,0x0c,0x0c,0x00}, // : {0x00,0x0c,0x0c,0x00,0x0c,0x04,0x08}, // ; {0x02,0x04,0x08,0x10,0x08,0x04,0x02}, // < {0x00,0x00,0x1f,0x00,0x1f,0x00,0x00}, // = {0x08,0x04,0x02,0x01,0x02,0x04,0x08}, // > {0x0e,0x11,0x01,0x02,0x04,0x00,0x04}, // ? {0x0e,0x11,0x01,0x0d,0x15,0x15,0x0e}, // @ {0x0e,0x11,0x11,0x1f,0x11,0x11,0x11}, // A {0x1e,0x11,0x11,0x1e,0x11,0x11,0x1e}, // B {0x0f,0x10,0x10,0x10,0x10,0x10,0x0f}, // C {0x1e,0x11,0x11,0x11,0x11,0x11,0x1e}, // D {0x1f,0x10,0x10,0x1f,0x10,0x10,0x1f}, // E {0x1f,0x10,0x10,0x1f,0x10,0x10,0x10}, // F {0x0f,0x10,0x10,0x16,0x11,0x11,0x0e}, // G {0x11,0x11,0x11,0x1f,0x11,0x11,0x11}, // H {0x0e,0x04,0x04,0x04,0x04,0x04,0x0e}, // I {0x0f,0x01,0x01,0x01,0x01,0x12,0x0c}, // J {0x11,0x12,0x14,0x18,0x14,0x12,0x11}, // K {0x10,0x10,0x10,0x10,0x10,0x10,0x1f}, // L {0x11,0x1b,0x15,0x11,0x11,0x11,0x11}, // M {0x11,0x11,0x19,0x15,0x13,0x11,0x11}, // N {0x0e,0x11,0x11,0x11,0x11,0x11,0x0e}, // O {0x1e,0x11,0x11,0x1e,0x10,0x10,0x10}, // P {0x0e,0x11,0x11,0x11,0x15,0x13,0x0f}, // Q {0x1e,0x11,0x11,0x1e,0x14,0x12,0x11}, // R {0x0f,0x10,0x10,0x0e,0x01,0x01,0x1e}, // S {0x1f,0x04,0x04,0x04,0x04,0x04,0x04}, // T {0x11,0x11,0x11,0x11,0x11,0x11,0x0e}, // U {0x11,0x11,0x11,0x11,0x11,0x0a,0x04}, // V {0x11,0x11,0x11,0x15,0x15,0x1b,0x11}, // W {0x11,0x11,0x0a,0x04,0x0a,0x11,0x11}, // X {0x11,0x11,0x11,0x0a,0x04,0x04,0x04}, // Y {0x1f,0x02,0x04,0x08,0x10,0x10,0x1f}, // Z {0x0c,0x08,0x08,0x08,0x08,0x08,0x0c}, // [ {0x00,0x10,0x08,0x04,0x02,0x01,0x00}, // '\' {0x03,0x01,0x01,0x01,0x01,0x01,0x03}, // ] {0x04,0x0a,0x11,0x00,0x00,0x00,0x00}, // ^ {0x00,0x00,0x00,0x00,0x00,0x00,0x1f}, // _ {0x08,0x04,0x02,0x00,0x00,0x00,0x00}, // ` }; unsigned char frame[56][7]; void delay_ms(unsigned int ms){ while (ms--) _delay_cycles(16000); } // delay_ms() void configure_clock(){ // MCLK et SMCLK à 16Mhz BCSCTL1 = CALBC1_16MHZ; DCOCTL = CALDCO_16MHZ; }//configure_clock() void clear_screen(){ unsigned char x,y; for(y=0;y<56;y++) for(x=0;x<7;x++) frame[y][x]=0; }//clear_screen() void dot(int x, int y){ frame[y][x>>3] |= (1<< (7-(x & 7))); } // dot() void erase_dot(int x, int y){ frame[y][x>>3] &= ~(1<< (7-(x & 7))); }//erase_dot() void swap(int* n1, int* n2){ int t; t=*n1; *n1=*n2; *n2=t; } int abs(int x){ return x>0?x:-x; } // abs() // REF: http://en.wikipedia.org/wiki/Bresenham's_line_algorithm void line(int x0, int y0, int x1, int y1){ int dx,dy, error,ystep,x,y; unsigned char steep = abs(y1 - y0) > abs(x1 - x0); if (steep) { swap(&x0, &y0); swap(&x1, &y1); } if (x0 > x1){ swap(&x0, &x1); swap(&y0, &y1); } dx = (x1 - x0); dy = abs(y1 - y0); error = dx>>1; y = y0; if (y0 < y1) ystep = 1; else ystep = -1; for (x=x0;x<=x1;x++){ if (steep) dot(y,x); else dot(x,y); error = error - dy; if (error < 0){ y = y + ystep; error = error + dx; } } } // line() void rectangle(int x0, int y0, int x1, int y1){ line(x0,y0,x1,y0); line(x1,y0,x1,y1); line(x0,y1,x1,y1); line(x0,y0,x0,y1); } // rectangle() void draw_char(int x, int y, unsigned char c){ int bit,row,byte; if (c>='a') c -=32; if (c<' ' || c>'z') return; c -= ' '; for (row=0;row<7;row++){ byte=font[c][row]; for (bit=4;bit>=0;bit--){ if (byte & (1<<bit)) dot(x,y); else erase_dot(x,y); x++; } x-=5; y++; } } // draw_char() const char msg[]="MSP430G2553 B/W NTSC video demo."; void print(int x, int y, const char* str){ int idx=0; while ((x<52) && (str[idx]!=0)){ draw_char(x,y,str[idx]); idx++; x+=6; } }// print() /* * main.c */ void main(void) { WDTCTL = WDTPW | WDTHOLD; // Stop watchdog timer configure_clock(); //confiugration E/S P1DIR |= VIDEO_OUT; P1OUT &= ~VIDEO_OUT; P2DIR = SYNC_OUT; // P2.1 en sortie P2SEL = SYNC_OUT; //minuterie sur P2.1 //configuration SPI sur UCB0 pour sortie vidéo UCB0CTL1 = UCSWRST; // désactivation du SPI UCB0CTL0 = UCMST+UCSYNC+UCMSB; UCB0BR0 = 13; // vitesse SPI = SMCLK/14 UCB0BR1 = 0; UCB0CTL1 |= 3<<6; // horloge source SMCLK UCB0CTL1 &= ~UCSWRST; // réactivation du SPI //configuration minuterie 1 pour syncho NTSC TA1CCR0=H_HALF_LINE; TA1CCR1=H_NARROW_SYNC; TA1CCR2=H_DISPLAY_DELAY; TA1CCTL1=OUTMOD_3; // mode toggle/set TA1CCTL0 = CCIE; TA1CCTL2 |= CCIE; TA1CTL = TASSEL_2+MC_1; // SMCLK, UP mode _enable_interrupts(); ln_cnt=1; display=0; unsigned char c; int x,y,len; while (1){ x=48; y=3*8; len=strlen(msg); while (x>=0){ print(x,y,(char*)&msg); delay_ms(80); // clear_screen(); x -= 6; } x=0; for (c=1;c<len;c++){ print(x,y,(char*)&msg+c); delay_ms(80); clear_screen(); } } }//main() #pragma vector=TIMER1_A0_VECTOR __interrupt void ta1_ccr0_isr(void){ ln_cnt++; switch (ln_cnt){ case 7: TA1CCR1=H_HALF_LINE-H_NARROW_SYNC; break; case 13: TA1CCR1=H_NARROW_SYNC; break; case 19: TA1CCR0=H_LINE; TA1CCR1=H_SYNC; break; case FIRST_LINE: // première avec affichage display=1; break; case LAST_LINE: // dernière ligne avec affichage display=0; break; case 272: // 9 lignes de plus car lors de la synchro il ln_cnt est incrément 2 fois par ligne normale. ln_cnt=1; TA1CCR0=H_HALF_LINE; TA1CCR1 = H_NARROW_SYNC; break; default:; } } // ta1_0_isr() #pragma vector=TIMER1_A1_VECTOR __interrupt void ta1_ccrx_isr(void){ unsigned int x,y; if ((TA1IV==TA1IV_TACCR2) & display){ P1SEL |= VIDEO_OUT; // sortie vidéo P1SEL2 |= VIDEO_OUT; // contrôlée par SPI y=(ln_cnt-FIRST_LINE)>>2; IFG2 &= ~UCB0TXIFG; for (x=0;x<7;x++){ UCB0TXBUF=frame[y][x]; while (!(IFG2 & UCB0TXIFG)); } while (UCB0STAT & UCBUSY); P1SEL &= ~VIDEO_OUT; // sortie vidéo P1SEL2 &=~VIDEO_OUT; // controlée par P1OUT } }

Standard NTSC

Le standard NTSC est le standard de la télé analogique mis au point dans les années 194x. Au départ c'était un standard pour le noir et blanc mais il a été révisé pour ajouter la couleur quelques années plus tard. Dans notre cas on n'est concerné que par la version noir et blanc. Le site internet le plus intéressant sur la description de ce standard est http://www.ntsc-tv.com. C'est grâce aux informations disponibles sur ce site que j'ai pu me débrouiller pour écrire ce programme.

Le signal vidéo NTSC est plutôt complexe, l'image est créé par 2 balayages (fields) en alternance. Un qui affiche les lignes paires et l'autre les lignes impaires. Chaque field est répété 30 fois par seconde. Chaque field est constitué de 262,5 lignes pour un total de 525 lignes. A cause de la persistance rétinienne on a l'impression que les 525 lignes sont affichées simultanément alors que ce n'est pas le cas. Ce système permet de réduire la bande passante du signal mais ça complique le système de synchronisation de l'image. Heureusement il est possible d'ignorer cette alternance paire/impaire et d'envoyer toujours le même field. On ne dispose alors que de 262 lignes d'affichage qui se répètent 60 fois par seconde. De ces 262 lignes 20 sont réservées pour la synchronisation verticale et donc indisponible pour l'affichage. Il ne reste donc que 240 lignes d'affichage soit la moitié d'un signal VGA.

Le circuit électronique est très simple il suffit d'une résistance de 470 ohm branchée sur P1.2 (sortie PWM) pour la synchronisation et d'une autre résistance de 220 ohm branchée sur la sortie P1.7 (sortie SIMO du SPI) pour le signal vidéo. Il n'y a pas de nuances de gris, c'est vraiment du noir et blanc. Les deux résistances sont jointent ensemble et ce point de jonction est la sortie vidéo qui va à l'entrée NTSC du téléviseur.

Configuration des périphériques

La partie synchronisation du signal est générée par PWM grâce à la minuterie TIMER_A1 configurée en mode comparateur avec comptage UP. TA1CCR0 détermine la période qui correspond à la durée d'une seule ligne vidéo soit 62,5µSec. Le DCO étant programmé pour fonctionner à 16Mhz, la période de cycle du SMCLK est de 62,5nSec, ce qui donne 1000 cycles par ligne. De ces 62,5µSec 10,5µSec sont réservés pour l'impulsion de synchronisation plus les seuils avant et arrière. Il reste donc 52µSec disponible pour l'affichage vidéo. Ce qui complique les choses est la synchronisation verticale. A toute les 262,5 lignes il faut générer une série d'impulsions dont la durée varie. 3 courtes, 3 longues et 3 courtes. Ce travail est accomplie dans la sous-routine d'interruption du compteur de période CCR0, appelée dans le programme ta1_ccr0_isr. le registre CCR1 est configuré pour déterminer la longueur de l'impulsion de synchronisation et CCR2 pour la durée du seuil. lorsque le compteur TA1R arrive à la valeur de CCR2 l'ISR ta1_ccrx_isr est appelée et celle-ci est responsable de l'affichage de l'image qui est contenu dans le tableau frame[56][7]. La résolution de l'image n'est que de 56x56 pixels du à la quantité limitée de mémoire RAM qui n'est que de 512 octets. De ces octets une certaine quantité est réservée pour la pile et les autres variables.

L'astuce intéressante est la façon d'utiliser un périphérique SPI pour sortir les bits vidéos. Le périphérique est configuré en mode SPI maître mais au lieu de brancher la sortie SIMO qui normalement envoie les octets vers un périphérique SPI esclave, on s'en sert comme sortie vidéo. le SPI et cadencé par le signal SMCLK divisé par 13. Ce diviseur et calculé pour que les 56 bits par ligne soient envoyées en un temps inférieur à 52µSec. 52µSec/56/62,5nSec= 14,8. J'ai utilisé 13 comme diviseur pour laissé une marge à la fin de la ligne pour être certain que la routine ISR se termine avant l'interruption de fin de ligne. Plus le diviseur est petit plus les pixels sont comprimés horizontalement. Chaque ligne du tableau frame est répétée 4 fois ce qui donne 4*56=224 lignes ce qui nous laisse aussi une marche verticalement.

A titre de démo je fais simplement défilé un texte au centre de l'écran.

Conclusion

Avec un affichage de 56x56 pixels noir/blanc on ne peut pas faire grand chose mais j'ai une idée sur la façon d'augmenter la mémoire vidéo. Puisqu'on utilise un périphérique SPI pour sortir les bits vidéo il serait simple d'utiliser une mémoire RAM externe à interface SPI comme la Microchip 23K256. Avec 32K de RAM SPI on a de la place pour plusieurs buffer de 5760 octets (192x240pixels). On interface la RAM avec le MCU de manière conventionnel mais on branche la sortie SOMI à l'entrée NTSC à travers une résistance de 220 ohm. Donc il suffit que le MCU fasse la lecture de la RAM SPI pour que les bits soient envoyés sur la sortie vidéo. Avec un tel système on pourrait obtenir une résolution vidéo de 320x240.

quelques liens intéressants sur ce sujet

Une image en FLASH affichée avec une résolution de 192x240.
Standard NTSC.
Exemple du jeux pong fourni par Texas Intruments slaa177.