VPC-32, test vidéo ntsc

J'ai débuté ce projet en faisant des tests de génération de signal vidéo NTSC B/N 320x230. Pourquoi pas 320x240 pour être conforme au standard QVGA?. En principe avec la méthode de scan utilisé on devrait obtenir 240 lignes visibles à l'écran, 262 moins les 20 lignes réservés au vertical retrace. Mais en pratique sur les 2 téléviseurs que j'ai essayé seulement 230 lignes sont visibles à l'écran. Je ne gaspillerai donc pas 400 octets de mémoire RAM pour des lignes qui ne sont pas visibles. Donc le tableau représentant le bitmap vidéo occupe 320x230/8 soit 9200 octets de RAM.

Circuit de test

Voici le circuit utilisé pour faire mes test vidéo. Cette partie du circuit ne devrait pas être modifiée en cours de projet. Le signal vidéo généré est conforme à mes attentes.

La diode D1 n'est pas strictement nécessaire, le circuit fonctionne sans elle, sauf que je constate que la réponse en haute fréquence est meilleure avec cette diode installée. Dans mon image test les lignes verticales les plus étroites se confondent lorsque je l'enlève.

RB7 broche 16 est une entrée de synchronisation pour le signal vidéo généré par un périphérique SPI. Ce signal provient d'un OC en sortie sur la broche 11. Les périphériques SPI sur les PIC32MX peuvent fonctionner en mode frame. Dans ce mode le SPI envoie des octets tant que l'entrée sync est active. Le signal de synchronisation en question est généré par un périphérique OC Output Compare et sert à retarder l'envoie du signal vidéo en début de ligne.

code source

test-NTSC.c
/* * File: test-ntsc.c * Author: Jacques Deschênes * Description: test génération signal vidéo NTSC sur PIC32MX150F128B. * Created on 20 août 2013, 08:48 */ #include <stdio.h> #include <stdlib.h> #include <sys/attribs.h> #include <plib.h> #include "font.h" // PIC32MX150F128B Configuration Bit Settings #include <xc.h> /* * la fréqueence PBCLK influence la largeur des pixels vidéo. Comme PBCLK==SYSCLK * on peut allonger les pixels en diminuant la fréquence légèrement. * pour une résolution horizontale de 320 pixels et une fréquence de 40Mhz le * meilleur diviseur pour le générateur BGR du SPI est de 2 ce qui donne * une fréquence de pixel de 40e6/(2*(2+1)=6,67Mhz et la durée total d'une * ligne vidéo est donc de 320/6,67e6= 48µSec. * En principe pour le standard NTSC on dispose de 52µSec par ligne vidéo. * En pratique on est plutôt à 51µSec. Donc ici on a 3µSec inutilisées. * en résuidant SYSCLK à 37,5Mhz on a 51,2µSec par ligne vidéo. Les pixels * sont donc moins compressé horizontalement. Mais sur certains téléviseurs * on peut perdre quelques pixels en bout de ligne. * la constante SPI_DLY doit-être ajustée en fonction de PBCLK pour que les * 320 pixels horizontals soient visibles. */ #define SYSCLK 37500000L // 37,5Mhz pour obtenir des pixels plus larges donne 51,2µSec pour 320pixels //#define SYSCLK 40000000L // 40Mhz donne 48µSec pour 320pixels.(diviseur BRG=2 donc Fpixel=PBCLK/(2*(2+1)) // DEVCFG3 // USERID = No Setting #pragma config PMDL1WAY = ON // Peripheral Module Disable Configuration (Allow only one reconfiguration) #pragma config IOL1WAY = ON // Peripheral Pin Select Configuration (Allow only one reconfiguration) #pragma config FUSBIDIO = ON // USB USID Selection (Controlled by the USB Module) #pragma config FVBUSONIO = ON // USB VBUS ON Selection (Controlled by USB Module) // DEVCFG2 #pragma config FPLLIDIV = DIV_2 // PLL Input Divider (2x Divider) #if SYSCLK==40000000L #pragma config FPLLMUL = MUL_16 // SYSCLK=40Mhz #else #pragma config FPLLMUL = MUL_15 // PLL Multiplier (15x Multiplier) SYSCLK=37,5Mhz #endif #pragma config FPLLODIV = DIV_2 // System PLL Output Clock Divider (PLL Divide by 2) // DEVCFG1 #pragma config FNOSC = PRIPLL // Oscillator Selection Bits (Primary Osc w/PLL (XT+,HS+,EC+PLL)) #pragma config FSOSCEN = OFF // Secondary Oscillator Enable (Disabled) #pragma config IESO = OFF // Internal/External Switch Over (Disabled) #pragma config POSCMOD = HS // Primary Oscillator Configuration (XT osc mode) #pragma config OSCIOFNC = OFF // CLKO Output Signal Active on the OSCO Pin (Disabled) #pragma config FPBDIV = DIV_1 // Peripheral Clock Divisor (Pb_Clk is Sys_Clk/1) #pragma config FCKSM = CSDCMD // Clock Switching and Monitor Selection (Clock Switch Disable, FSCM Disabled) #pragma config WDTPS = PS1048576 // Watchdog Timer Postscaler (1:1048576) #pragma config WINDIS = OFF // Watchdog Timer Window Enable (Watchdog Timer is in Non-Window Mode) #pragma config FWDTEN = OFF // Watchdog Timer Enable (WDT Disabled (SWDTEN Bit Controls)) #pragma config FWDTWINSZ = WISZ_25 // Watchdog Timer Window Size (Window Size is 25%) // DEVCFG0 #pragma config JTAGEN = OFF // JTAG Enable (JTAG Disabled) #pragma config ICESEL = ICS_PGx1 // ICE/ICD Comm Channel Select (Communicate on PGEC1/PGED1) #pragma config PWP = OFF // Program Flash Write Protect (Disable) #pragma config BWP = OFF // Boot Flash Write Protect bit (Protection Disabled) #pragma config CP = OFF // Code Protect (Protection Disabled) #define PBCLK SYSCLK #define PWM_PERIOD (SYSCLK/15748)-1 #define HSYNC (SYSCLK/212766) // 4,7µSec #define FIRST_LINE 27 //première ligne de scan visible #define LAST_LINE 256 // dernière ligne de scan visible #define VRES 230 // résolution verticale #define HRES 320 // résolution horizontale #define BITCLK HRES * 1000000L/52 // 52µSec c'est le temps que dure 1 ligne vidéo. #define SPI_DLY HSYNC+35 // délais en début de ligne avant l'envoie du signal vidéo. #define _enable_video_out() SPI1CONSET=(1<<15) #define _disable_video_out() SPI1CONCLR=(1<<15) unsigned int video_bmp[VRES][HRES/32]; // video bitmap 7168 octets volatile unsigned int ln_cnt; volatile unsigned int video; volatile int *DmaSrc; void put_char(int x, int y, char c){ register int i,l,r,b; if (c>='a'){ c -= 32; } c -=32; b=x>>5; r=0; l=27-(x&0x1f); if (l<0){ r=-l; } for (i=0;i<7;i++){ if (r){ video_bmp[y][b] |= font[c][i]>>r; video_bmp[y][b+1] |= font[c][i]<<(32-r); y++; } else{ video_bmp[y++][b] |= font[c][i]<<l; } } }//put)char() const char *msg2=" test video ntsc "; const char *msg1="01234567890123456789012345678901234567890123456789012"; // 53 caractères par ligne void print(int x, int y, const char *text){ while (*text){ put_char(x, y, *text++); x += 6; if (x>HRES-6) break; } }// print() void test_pattern(void){ int i,j; for (i=0;i<VRES;i++){ video_bmp[i][0]=0x80000000; video_bmp[i][HRES/32-1]=1; } for (i=0;i<HRES/32;i++){ video_bmp[0][i]=0xffffffff; video_bmp[VRES-1][i]=0xffffffff; } for (i=VRES/4;i<VRES/2+VRES/4;i++){ video_bmp[i][2]=0xFF00FF00; video_bmp[i][3]=0xF0F0F0F0; video_bmp[i][4]=0xcccccccc; video_bmp[i][5]=0xaaaaaaaa; }//i print(2,3,msg1); print(2,12,msg2); }//test_pattern() void init_video(void){ //configuration PWM sur OC2 pour SYNC, utilisation TIMER2 RPB5Rbits.RPB5R=5; // 5=OC2 sortie SYNC T2CON = 0; PR2=PWM_PERIOD; OC2CONbits.OCM = 5; // mode train d'impulsion OC2RS = 0; OC2R = HSYNC; IFS0bits.T2IF=0; IEC0bits.T2IE=1; IPC2bits.T2IP=7; IPC2bits.T2IS=3; OC2CONbits.ON =1; // activation T2CONbits.ON=1; // activation //configuration PWM sur OC1 puor délais vidéo, utilisation TIMER2 RPB4Rbits.RPB4R=5; // 5=OC1 impulsion déclenchant SPI OC1CONbits.OCM = 5; //mode train d'impulsion OC1RS=0; OC1R=HSYNC+SPI_DLY; OC1CONbits.ON=1; // configuration SPI pour sortie vidéo RPB6Rbits.RPB6R=3; // 3=SDO1 sortie vidéo SS1Rbits.SS1R=4; // entrée Fsync sur RPB7 // configure le DMA DmaChnOpen(0,0,DMA_OPEN_DEFAULT); DmaChnSetEventControl(0,DMA_EV_START_IRQ_EN| DMA_EV_START_IRQ(_SPI1_TX_IRQ)); DmaChnSetTxfer(0,(void *)DmaSrc,(void *)&SPI1BUF,HRES/8,4,4); // configuration du SPI canal 1 SPI1CONbits.DISSDI=1; // SDI n'est pas utilisé. SPI1CONbits.FRMEN=1; // frame mode SPI1CONbits.FRMCNT=5; // 32 octets par frame. SPI1CONbits.FRMPOL=1; // sync sur transition montante SPI1CONbits.FRMSYNC=1; // synchronisation esclave SPI1CONbits.MSTEN=1; // SPI maître // SPI1CONbits.SPIFE=1; // synchronisation sur clock premier bit. SPI1CONbits.MODE32=1; // mode 32 bits SPI1CONbits.STXISEL=1; // interruption sur TBE SpiChnSetBitRate(SPI_CHANNEL1, PBCLK, BITCLK); SPI1CONbits.ON=1; }//init_video() void main(void) { INTEnableSystemMultiVectoredInt(); ln_cnt=0; video=0; test_pattern(); init_video(); while(1){ } } #define DLY 10 void __ISR(_TIMER_2_VECTOR,IPL7SRS) tmr2_isr(void){ _disable_video_out(); ln_cnt++; switch (ln_cnt){ case 1: // début vsync OC2R=PWM_PERIOD-HSYNC; break; case 4: // fin vsync OC2R=HSYNC; break; case 262: //fin du frame ln_cnt=0; break; case FIRST_LINE-1: video=1; DmaSrc=(void*)&video_bmp[0]; break; case LAST_LINE+1: video=0; break; default: if (video){ _enable_video_out(); //SPI1BUF=0; IFS1bits.SPI1TXIF=1; DCH0SSA=KVA_TO_PA((void *)DmaSrc); DmaSrc +=HRES/32; DmaChnEnable(0); } }//switch (ln_cnt) mT2ClearIntFlag(); }//tmr2_isr()

font.h
/* * File: font.h * Author: Jacques * * Created on 23 août 2013, 07:32 */ #ifndef FONT_H #define FONT_H #ifdef __cplusplus extern "C" { #endif // 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}, // ` }; #ifdef __cplusplus } #endif #endif /* FONT_H */

Les MCU PIC32MX possèdent 4 canaux DMA (Direct Memory AAccess). L'utilisation du DMA pour envoyer les bits vidéo au SPI permet d'accaparer le MCU un temps minimum pour la génération du signal vidéo. En effet le DMA va chercher les octets directement dans la mémoire RAM pour les envoyer au SPI sans intervention du core MCU qui lui pendant ce temps peut s'occuper à d'autres tâches.
Au niveau logiciel ce qui m'a donné de la difficulté c'est d'obtenir un signal avec une bonne synchronisation horizontale. Dans mes premiers essais le démarrage du signal vidéo était déterminer par un délais logiciel. Hors une interruption même au niveau de priorité le plus élevé a un temps de latence variable car le MCU doit compléter l'instruction en cours avant de répondre à l'interruption. Le résultat était des lignes verticales en dent de scie et les caractères étaient déformés. J'ai trouvé la solution de ce problème dans le livre de Lucio Di Jasio, Programming 32-bit Microntrollers in C¹. La solution consiste a utiliser le mode frame sur le SPI qui génère le signal vidéo et à déclencher le départ part un signal matériel qui lui ne subit pas de variation temporelle. Pour arriver à ce résultat Jasio utilise la transition montante de l'impulsion de synchronisation horizontale du signal NTSC. Mais comme il doit y avoir un délais d'au minimum 4,7µSec entre la fin de cette impulsion et le début du signal vidéo on doit trouver une façon d'introduire un délais supplémentaire. Pour introduire ce délais Jasio utilise un deuxième canal DMA qui envoie des 0 au SPI. Donc un délais en multiple de 32 bits peut être ajouté en début de ligne avant que le vrai signal vidéo soit envoyé. Sur les PIC32 les canaux DMA peuvent-être mis en chaîne. Donc le premier canal envoie un certain nombre de zéros pour créer un délais et lorsqu'il a terminé sa tâche déclenche le deuxième canal qui lui envoie les vrai bits vidéo au SPI.

Même si le livre de Jasio a été une source d'inspiration j'utilise une méthode différente pour générer le délais. Ma méthode permet une résolution du délais beaucoup plus fine. Cette résolution est en fait celle de la période du signal PBCLK qui alimente le TIMER 2. Donc au lieu d'utiliser un deuxième canal DMA j'utilise un deuxième OC qui est cadencé par le TIMER 2 comme celui qui génère le signal de synchronisation NTSC. J'ai donc 2 signaux de sortie OC en phase, celui sur la broche 14 qui est la synchro NTSC et celui sur la broche 11 qui est la synchro pour déclencher le SPI. Il suffit d'ajuster la constante SPI_DLY pour que la transition montante soit retardée d'au moins 5µsec par rapport à celle de HSYNC pour que le signal vidéo parte au bon moment. Et d'utiliser cette transition montante à la place de celle de HSYNC pour déclencher le SPI.

Avec cette méthode j'obtiens un signal vidéo parfais et je peux ajuster finement la position horizontale simplement en modifiant SPI_DLY. Étant donné la qualité du signal obtenu ce code va probablement demeuré tel quel dans la version finale du projet.

---

NOTES:
1) Programming 32-bit Microcontrollers in C, Exploring PIC32, Lucio Di Jasio, ed. Newnes