Pong sur PIC10F322

Pong est le premier jeux vidéo commercialisé pour l'usage à domicile au début des années 70. Après avoir vu ce jeux réalisé sur un PIC12F1840, je me suis demandé s'il serait possible de le réaliser sur un MCU encore plus petit. Pour le savoir il fallait tenter l'expérience. Ce que j'ai fait avec succès.

démo sur youtube

Circuit électronique

matériel requis

• 1 microcontrôleur Microchip PIC10LF322
• 2 prise audio RCA
• 1 condensateur céramique 100nF
• 1 condensateur électrolytique 10µF
• 1 commutateur ON/OFF pour l'alimentation
• 2 piles 1,5Volt pour l'alimentation
• 1 diode 1N4148
• 2 transistors NPN 2N3904
• 2 résistance 1K 1/4watt
• 3 résistances 10K 1/4watt
• 1 résistances 470R 1/4watt
• 3 résistance 4k7 1/4watt
• 1 résistance 100R 1/4watt
• 4 boutons à contact momentané

montage prototype

Le circuit est conçu pour fonctionner avec une alimentation de 3 à 3,6 volt. RA0 est la sortie vidéo qui est ajoutée au signal de synchronisation NTSC qui sort sur RA1. RA2 est la sortie audio mais sert aussi d'entrée pour les boutons de contrôle qui déplacent les raquettes vers le bas. RA3 est utiliser pour les boutons qui déplacent les raquettes vers le haut. L'agencement des transistors Q1 et Q2 permet de sélectionner quel boutons sont lus puisqu'on ne dispose que de 2 entrées on doit les lire en alternance. la sortie vidéo RA0 est utilisée pour sélectionner la lecture joueur gauche/joueur droite. Lorsque la sortie RA0 est à 3 volt le transistor Q1 est en saturation alors que Q2 est bloqué. Ce qui permet seulement aux boutons de gauche de fonctionner. Lorsque la sortie RA0 est à 0 volt Q1 est bloqué et Q2 est en saturation permettant aux boutons de droite de fonctionner. Cette lecture n'interfère pas avec le signal vidéo ni la sortie audio car elle n'est effectuée que lorsqu'il n'y a pas de son et de vidéo en sortie.

Le code source

L'ensemble du projet est sur https://github.com/Picatout/pong. Le programme comprends 2 fichiers, pic10f322_m.inc est un fichier de macros d'usage général. Le programme principal est dans le fichier mini-pong.asm. Le programme est entièrement écris en assembleur et occupe presque la totalité de la mémoire flash soit 510 des 512 instructions possible. 42 octets RAM sont attribués à la mémoire bitmap vidéo. La minuterie TIMER2 est utilisée pour générer le signal de synchronisation NTSC par PWM. Une interruption se produit à la fin de chaque cycle PWM. Toute la logique du programme s'exécute à l'intérieur de cette interruption. Les tâches à exécuter sont cédulées selon le numéro de ligne conservé dans la variable ln_cnt. Au début de l'interruption la variable est incrémentée ensuite le céduleur choisi la tâche a exécuter en fonction de cette valeur. Étant donner que la tâche video_output a la plus haute priorité elle est cédulée avant toutes les autres. Les autres tâches ne sont exécutées que lorsqu'il n'y a pas de sortie vidéo. Chaque tâche doit-être complétée avant la fin du cycle PWM donc avoir une durée inférieure à 63,5µSec.

pic10f322_m.inc
;NAME: pic10f322_m.inc ;DESCRIPTION: macros utiles lors de l'utilisation du PIC10F322 ;AUTEUR: Jacques Deschênes ;DATE: 2012-10-17 ;DERNIÈRE RÉVISION: 2012-11-12 #include P10F322.INC constant MAXRAM = 0x7F constant MAXFLASH = D'512' constant MINRAM = 0x40 constant BANKS = 1 ; 1 seule banque de RAM constant PAGES = 2 ; 2 pages de FLASH constant ROWSIZE = D'16' ; nombre de mots dans 1 ligne pour la programmation FLASH #define _MCLRE_REALLY_OFF ( _MCLRE_OFF & _LVP_OFF ) #define default_config __config _MCLRE_REALLY_OFF & _WDTE_SWDTEN & _FOSC_INTOSC wait_hfosc_stable macro ; attend que l'oscillateur haute fréquence interne soit stable btfss OSCCON, HFIOFR goto $-1 btfss OSCCON, HFIOFS goto $-1 endm wait_lfosc_ready macro ; attend que l'oscillateur interne basse fréquence btfss OSCCON, LFIOFR ; soit prêt goto $-1 endm clear_ram macro ; mise à zéro de la RAM movlw MINRAM movwf FSR clear_ram_loop clrf INDF incf FSR btfss FSR,7 goto clear_ram_loop endm basic_setup macro ; désactive tous les périphériques. clrf INTCON ; désactivation interruption clrf ANSELA bcf CLKRCON, CLKROE ; pas de sortie de Fosc/4 bcf FVRCON, FVREN ; désactive la référence de voltage fixe bcf T2CON, TMR2ON ; désactive le timer2 bcf PWM1CON, PWM1EN ; désactive le PWM1 bcf PWM2CON, PWM2EN ; désactive le PWM2 bcf CLC1CON, LC1EN ; désactive CLC1 bcf NCO1CON, N1EN ; désactive le NCO bcf CWG1CON0, G1EN ; désactive le CWG1 clrf OPTION_REG bsf OPTION_REG, PSA ; pré-scale désactivé movlw 0xF movwf TRISA ; toutes des entrées movwf WPUA ; active les pullup endm constant OUT = 0 constant INP = 1 set_io_dir macro pin, dir ; établi une broche comme entrée ou sortie if dir bsf TRISA, pin ; input else bcf TRISA, pin ; output endif endm set_clk_freq macro freq; initialize clock frequency movlw B'00001111' andwf OSCCON, F if freq == D'31' exitm endif if freq == D'250' movlw B'00010000' iorwf OSCCON, F exitm endif if freq == D'500' movlw B'00100000' iorwf OSCCON, F exitm endif if freq == D'1' movlw B'00110000' iorwf OSCCON, F exitm endif if freq == D'2' movlw B'01000000' iorwf OSCCON, F exitm endif if freq == D'4' movlw B'01010000' iorwf OSCCON, F exitm endif if freq == D'8' movlw B'01100000' iorwf OSCCON, F exitm endif if freq == D'16' movlw B'01110000' iorwf OSCCON, F endif endm enable_clk_out macro ; active la sortie Fosc/4 sur RA2 bcf NCO1CON, N1OE bsf CLKRCON, CLKROE endm disable_clk_out macro ; désactive la sortie Fosc/4 sur RA2 bcf CLKRCON, CLKROE endm enable_interrupt macro ; active les interruption bsf INTCON, GIE endm disable_interrupt macro ; désactive les interruption bcf INTCON, GIE endm enable_periph_int macro ; active les interruptions périphériques bsf INTCON, PEIE endm disable_periph_int macro ; désactive les interruptions périphérique bcf INTCON, PEIE endm enable_ext_int macro ; active l'interruption externe bsf INTCON, INTE endm disable_ext_int macro ; désactive les interruption externe bcf INTCON, INTE endm bra_ext_int macro address ; branchement sur interruption externe btfsc INTCON, INTF goto address endm enable_tmr0_int macro ; active l'interruption du timer0 bcf INTCON, TMR0IF bsf INTCON, TMR0IE endm disable_tmr0_int macro ; désactive l'interruption du timer0 bcf INTCON, TMR0IE endm bra_tmr0_int macro address ; branchement sur interruption timer0 btfsc INTCON, TMR0IF goto address endm enable_tmr2_int macro ; active les interruptions sur timer2 bsf PIE1, TMR2IE endm disable_tmr2_int macro ; désactive les interruptions sur timer2 bcf PIE1, TMR2IE endm ;;;;;;;;;;;;; IOC interrupt changement d'état de broche ;;;;;;;;;;;;;;; enable_ioc_int macro ; active les interruptions sur changement d'état E/S bcf INTCON, IOCIF clrf IOCAF bsf INTCON, IOCIE endm disable_ioc_int macro ; désactive les interruptions sur changement d'état E/S bcf INTCON, IOCIE endm constant IOC_RISING = 0 constant IOC_FALLING = 1 constant IOC_BOTH = 2 set_ioc_edge macro pin, edge ; sur quel changement doit se produire l'interruption if edge == IOC_RISING bsf IOCAP, pin bcf IOCAN, pin exitm endif if edge == IOC_FALLING bsf IOCAN, pin bcf IOCAP, pin exitm endif bsf IOCAN, pin bsf IOCAP, pin endm clear_ioc_flag macro ; remet à zéro les drapeaux indicateurs movlw 0xF0 andwf IOCAF,F endm bra_ioc_int macro address ; branche sur interruption causé par un changement btfsc INTCON, IOCIF ; d'état E/S goto address endm clear_ioc_if macro ;remet à zéro le drapeu d'interruption bcf INTCON, IOCIF movlw H'FF' xorwf IOCAF, W andwf IOCAF, F endm ;;;;;;;;;; adc interrtupt ;;;;;;;;;;;;;;;;;;; enable_adc_int macro ; active les interruptions sur ADC bsf PIE1, ADIE endm disable_adc_int macro ; désactive les interruptions sur ADC bcf PIE1, ADIE endm bra_adc_int macro address ; branchement sur interruption ADC btfsc PIR1, ADCIF goto address endm enable_nco1_int macro ; active les interruptions sur nco1 bsf PIE1, NCO1IE endm disable_nco1_int macro ; désactive les interruptions sur nco1 bcf PIE1, NCO1IE endm bra_nco1_int macro address ; branchement sur interruption nco1 btfsc PIR1, NCO1IF goto address endm enable_clc1_int macro ; active les interruptions sur clc1 bsf PIE1, CLC1IE endm disable_clc1_int macro ; désactive les interruptions sur clc1 bcf PIE1, CLC1IE endm bra_clc1_int macro address ; branchement sur interruption clc1 btfsc PIR1, CLC1IF goto address endm bra_tmr2_int macro address ; branchement sur interruption timer2 btfsc PIR1, TMR2IF goto address endm constant IOC_INT = 0 constant EXT_INT = 1 constant TMR0_INT = 2 constant TMR2_INT = D'8'+1 constant CLC1_INT = D'8'+3 constant NCO1_INT = D'8'+4 constant ADC_INT = D'8'+6 bra_int macro int_src, address ;branche à l'adresse s'il la source de ; l'interruption est int_src if int_src < D'8' btfsc INTCON, int_src goto address exitm end if btfsc PIR1, (int_src - D'8') goto address endm ;;;;;;;;;;; convertisseur analogue/numérique ;;;;;;;;;;;;;;; disable_adc macro ; déssactive le convertisseur A/N bcf ADCON, ADON clrf ANSELA endm enable_adc macro ; active le convertisseur mais ne sélectionne pas de d'entrée clrf ANSELA ; aucune entrée ANx de sélectionnée. movlw B'00011111' ; efface la sélection freq. d'horlorge andwf ADCON, F movlw B'01100001' ; horloge = Frc, ADON=1 iorwf ADCON, F endm constant ADC_CLK_FOSCDIV2 = 0 constant ADC_CLK_FOSCDIV8 = 1 constant ADC_CLK_FOSCDIV32 = 2 constant ADC_CLK_FRC = 3 constant ADC_CLK_FOSCDIV4 = 4 constant ADC_CLK_FOSCDIV16 = 5 constant ADC_CLK_FOSCDIV64 = 6 constant ADC_CLK_FRC2 = 7 select_adc_clk macro clk ; sélection du signal horloge pour la conversion A/N movlw clk << 5 iorwf ADCON endm constant INP_MODE_DIG = 0 constant INP_MODE_AN = 1 set_inp_mode macro pin, mode ; sélectionne le mode d'entrée d'une broche digital ou analogue if mode == INP_MODE_DIG ; pin = {RA0,RA1,RA2} bcf ANSELA, pin ; mode = {INP_MODE_DIG, INP_MODE_AN} else bsf ANSELA, pin endif endm ; canaux lecture analogue/numérique constant CH_AN0 = B'00000000' constant CH_AN1 = B'00000100' constant CH_AN2 = B'00001000' constant CH_TEMP = B'00011000' constant CH_FVR = B'00011100' select_adc_channel macro ch ; sélection sur quel canal faire la lecture movlw B'11100011' andwf ADCON, F movlw ch iorwf ADCON, F if ch == CH_AN0 bsf ANSELA, 0 endif if ch == CH_AN1 bsf ANSELA, 1 endif if ch == CH_AN2 bsf ANSELA, 2 endif endm start_adc macro ; démarre une lecture mais n'attend pas la fin bcf PIR1, ADIF bsf ADCON, GO_NOT_DONE endm read_adc macro ; démarre et attend que la lecture soit complétée btfss ADCON, GO_NOT_DONE bsf ADCON, GO_NOT_DONE btfsc ADCON, GO_NOT_DONE goto $-1 endm ;;;;;;;;;;;;;;; FVR: référence de voltage fixe ;;;;;;;;;;;;; enable_fvr macro ; active la référence bsf FVRCON, FVREN btfss FVRCON, FVRRDY goto $-1 endm disable_fvr macro ; désactive la référence bcf FVRCON, FVREN endm constant FVR_0V = 0 constant FVR_1V = 1 constant FVR_2V = 2 constant FVR_4V = 3 set_fvr_volt macro gain ; défini la valeur de sortie de la référence movlw gain iorwf FVRCON, F endm ;;;;;;;;;;;;; IVR, régulateur de tension interne ;;;;;;;;;;;;; enable_power_save macro ; active l'économie d'énergie en mode sleep bsf VREGCON, VREGPM1 end disable_power_save macro ; désactive l'économie d'énergie en mode sleep bcf VREGCON, VREGPM1 endm ;;;;;;;;;;;;; référence température ;;;;;;;;;;;;;;;;; enable_temp macro ; active le capteur de température bsf FVRCON, TSEN endm disable_temp macro ; désactive le capteur de températeur bcf FVRCON, TSEN endm constant TEMP_RANGE_LOW = 0 constant TEMP_RANGE_HIGH = 1 set_temp_range macro range ; définie le range de lecture du capteur de températeur if TEMP_RANGE_LOW == 0 bcf FVRCON, TSRNG else bsf FVRCON, TSRNG endif endm ;;;;;;;;;;;;;;;;;; NCO générateur numériquement programmable ;;;;;;;;;;; enable_nco macro ; active le générateur bsf NCO1CON, N1EN endm disable_nco macro ; désactive le générateur bcf NCO1CON, N1EN endm enable_nco_output macro ; active la sortie sur RA2 bsf NCO1CON, N1OE endm disable_nco_output macro ; désactive la sortie sur RA2 bcf NCO1CON,N1OE endm constant NCO_CLK_NCO1CLK = 0 ; entrée broche NCO1 constant NCO_CLK_FOSC = 1 ; fréquence oscillateur MCU constant NCO_CLK_INTOSC = 2 ;oscillateur interne haute fréquence constant NCO_CLK_LC1OUT = 3 ; sortie cellule CLC1 set_nco_clock macro clk ; défini la source horloge du NCO movlw 0xFC andwf NCO1CLK, F if clk > 0 movlw clk iorwf NCO1CLK, F endif endm constant NCO_POL_LOW = 0 constant NCO_POL_HIGH = 1 set_nco_output_polarity macro pol ; défini la polarité active if pol == NCO_POL_LOW bcf NCO1CON, N1POL else bsf NCO1CON, N1POL endif endm constant NCO_MODE_SQUARE_WAVE = 0 constant NCO_MODE_PULSE = 1 set_nco_mode macro mode ; if mode == NCO_MODE_PULSE bsf NCO1CON, N1PFM else bcf NCO1CON, N1PFM endif endm set_nco_pulse_width macro width ; largeur de l'impulsion en multiple de signal horloge movlw 0x1F ; width {0-7} pulse_width = 2^^width andwf NCO1CLK, F movlw width << 5 iorwf NCO1CLK, F endm set_nco_incr macro incr ; défini l'incrément du NCO movlw incr>>8 movwf NCO1INCH movlw incr & 0xFF movwf NCO1INCL endm ;;;;;;;;;;;;;;;;;; TIMER 0 ;;;;;;;;;;;;;;;;;;;;;;;; constant TMR0_EXT_CLK = 1 constant TMR0_FOSC4 = 0 set_timer0_clock macro clk ; signal utilisé à l'entrée du timer 0 if clk == TMR0_EXT_CLK bsf OPTION_REG, T0CS else bcf OPTION_REG, T0CS endif endm constant TMR0_DIV2 = 0 constant TMR0_DIV4 = 1 constant TMR0_DIV8 = 2 constant TMR0_DIV16 = 3 constant TMR0_DIV32 = 4 constant TMR0_DIV64 = 5 constant TMR0_DIV128 = 6 constant TMR0_DIV256 = 7 set_timer0_prescale macro div ; défini le diviseur du timer0 { 0-7 } movlw 0xF0 ; diviseur = 2^^(div+1) andwf OPTION_REG,F if div != 0 movlw div iorwf OPTION_REG, F endif endm disable_timer0_prescale macro ; désactive le diviseur bsf OPTION_REG, PSA endm init_timer0 macro count ; initialise le TIMER 0 avec la valeur count movlw count ; 0 - 255 movwf TMR0 endm wait_timer0_rollover macro ; attend que le count du timer0 revienne à zéro movfw TMR0 ; ne fonctionne que si le diviseur >= 4 skpz goto $-2 endm ;;;;;;;;;;;;;;;;;;;;; TIMER 2 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; enable_timer2 macro ;activation du timer 2 bsf T2CON, TMR2ON endm disable_timer2 macro ; désactivation du timer 2 bcf T2CON, TMR2ON endm constant TMR2_DIV1 = 0 ; pas de division constant TMR2_DIV4 = 1 ; divise par 4 constant TMR2_DIV16 = 2 ; divise par 16 constant TMR2_DIV64 = 3 ; divise par 64 set_timer2_prescale macro div ; ajuste le prédiviseur du timer 2 movlw 0xFC andwf T2CON,F if div > 0 movlw div iorwf T2CON, F endif endm constant TMR2_PS1 = 0 ; pas de divisition constant TMR2_PS2 = 1 constant TMR2_PS3 = 2 constant TMR2_PS4 = 3 constant TMR2_PS5 = 4 constant TMR2_PS6 = 5 constant TMR2_PS7 = 6 constant TMR2_PS8 = 7 constant TMR2_PS9 = D'8' constant TMR2_PS10 = D'9' constant TMR2_PS11 = D'10' constant TMR2_PS12 = D'11' constant TMR2_PS13 = D'12' constant TMR2_PS14 = D'13' constant TMR2_PS15 = D'14' constant TMR2_PS16 = D'15' set_timer2_postscale macro div ; ajuste le postdiviseur du timer 2 movlw 0x7 andwf T2CON, F movlw div << 3 iorwf T2CON, F endm init_timer2 macro count ; charge le registre TMR2 avec count movlw count movwf TMR2 endm init_timer2_period macro count ; charge le registre PR2 avec count movlw count movwf PR2 endm ;;;;;;;;;;;;;;;;; module PWM ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; constant PWM_CH1 = 1 constant PWM_CH2 = 2 enable_pwm_channel macro channel ; active le canal pwm 1 ou 2 if channel == PWM_CH1 bsf PWM1CON, PWM1EN else bsf PWM2CON, PWM2EN endif endm disable_pwm_channel macro channel ; désactive le canal pwm 1 ou 2 if channel == PWM_CH1 bcf PWM1CON, PWM1EN else bcf PWM2CON, PWM2EN endif endm enable_pwm_output macro channel ; active la sortie pwm du canal 1 ou 2 if channel == PWM_CH1 bsf PWM1CON, PWM1OE else bsf PWM2CON, PWM2OE endif endm disable_pwm_output macro channel ; désactive la sortie pwm du canal 1 ou 2 if channel == PWM_CH1 bcf PWM1CON, PWM1OE else bcf PWM2CON, PWM2OE endif endm constant PWM_POL_H = 0 constant PWM_POL_L = 1 set_pwm_polarity macro channel, pol ; défini la polarité de la sortie if channel == PWM_CH1 if pol==PWM_POL_H bcf PWM1CON, PWM1POL else bsf PWM1CON, PWM1POL endif else if pol==PWM_POL_H bcf PWM2CON, PWM2POL else bsf PWM2CON, PWM2POL endif endif endm set_pwm_duty_cycle macro channel, duty ; défini le dudy cycle if channel == PWM_CH1 movlw (duty & 0x3FF) >> 2 movwf PWM1DCH movlw (duty & 0x3) << 6 movwf PWM1DCL else movlw (duty & 0x3FF) >> 2 movwf PWM2DCH movlw (duty & 0x3) << 6 movwf PWM2DCL endif endm ;;;;;;;;;;;;; CLC cellule logique configurable ;;;;;;;;;;;;;;;; enable_clc macro ; active la cellule bsf CLC1CON, LC1EN endm disable_clc macro ; désactive la cellule bcf CLC1CON, LC1EN endm enable_clc_output macro ; active la sortie bsf CLC1CON, LC1OE endm disable_clc_output macro ; désactive la sortie bcf CLC1CON, LC1OE endm ;;;;;;;;;;;;;;;;;; CWG générateur d'onde complémentaire ;;;;;;;;;;;;;; enable_cwg macro bsf CWG1CON0, G1EN endm disable_cwg macro bcf CWG1CON0, G1EN endm constant CWG_OUTA = G1OEA constant CWG_OUTB = G1OEB enable_cwg_output macro out ; active la sortie A ou B bsf CWG1CON0, out endm disable_cwg_output macro out ; désactive la sortie A ou B bcf CWG1CON0, out endm constant CWG_INP_PWM1 = 0 constant CWG_INP_PWM2 = 1 constant CWG_INP_NCO = 2 constant CWG_INP_CLC = 3 select_cwg_input macro inp ; sélectionne le signal d'entrée movlw 0xFC andwf CWG1CON1, F if inp != 0 movlw inp iorwf CWG1CON1, F endif endm ;;;;;;;;;;;;;; lecture de la mémoire flash en exécution ;;;;;;;; read_prog_mem macro addr ; fait la lecture d'un addresse movlw high addr ; le résultat est dans PMDATL et PMDATH movwf PMADRH movlw low addr movwf PMADRL bcf PMCON1, CFGS bsf PMCON1, RD nop nop endm mini-pong.asm
; NOM: mini-pong ; DESCRIPTION: Jeux mini-pong 16x21 pixels sur pic10f322 ; sortie vidéo NTSC ; sortie audio ; pointage indiqué en haut de l'écran ; chaque joueur contrôle sa raquette à l'aide ; de 2 boutons ; au démarrage la joeur de gauche a le service ; et doit déplacer sa raquette pour démarrer la partie ; ; Le TIMER2 génère le signal de synchronisation NTSC ; et une interruption est générer à la fin de chaque ; cycle. Toute la logique du programme s'exécute ; à l'intérieur de cette interruption. ; la variable 'ln_cnt' compte les lignes de scan vidéo NTSC ; mais est utilisée aussi par le céduleur de tâches. ; le NCO génère le son produit lorsque la balle rebondi sur ; une raquette ou un bord ainsi que le son plus grave et prolongé ; lorsqu'un joueur manque la balle. ; ; AUTEUR: Jacquees Deschênes ; DATE: 2013-08-10 include <p10f322.inc> include "include\pic10f322_m.inc" radix dec __config _FOSC_INTOSC & _MCLRE_OFF & _LVP_OFF & _WDTE_OFF & _CP_ON ; constantes #define PWM_PERIOD 254 ; peut nécessiter un ajustement de quelques unités (252-255) ; dépend de la fréquence du HFOSC qui peut varier ; d'un MCU à l'autre. #define SYNC_WIDTH 75 ; largeur de l'impulsion de synchronisation horizontale ; signal NTSC. ; indicateurs booléens dans variable 'flags' #define F_BIT9 0 ; 9ième bit de ln_cnt #define F_VIDEO 1 ; affichage actif #define F_TONE 2 ; son actif #define F_PAUSE 3 ; action arrêtée #define F_SERVE 4 ; qui a le service, 0 gauche, 1 droite #define F_SCORE 5 ; 0 point à gauche, 1 point à droite #define F_MOVED 6 ; le joueur qui a le service a bougé sa raquette ;#define F_LMOVED 7 ; joueur de gauche a bougé sa raquette #define VIDEO_OUT RA0 ; sortie signal vidéo #define SYNC_OUT RA1 ; sortie synchronisation NTSC #define AUDIO_OUT RA2 ; sortie audio #define DOWN_BTN RA2 ; bouton déplacement vers le bas #define UP_BTN RA3 ; vers le haut #define BALL_DLY 10 ; détermine la vitesse de la balle #define SCORE_TONE 30 ; tonalité lorsqu'un point est compté #define SCORE_LENGTH 50 ; durée de la tonalité #define PING_TONE 58 ; tonalité lorsque la balle frappe la raquette ou rebondie. #define PING_LENGTH 6 ; durée #define BTN_DLY 14 ; détermine la vitesse des raquettes ; macros delay_us macro us ; délais en micro-secondes, overhead 250nsec. movlw us addlw H'FF' skpz goto $-2 endm tone macro freq ; démarre la tonalitée set_nco_incr freq enable_nco_output bsf flags, F_TONE if freq==PING_TONE movlw PING_LENGTH else movlw SCORE_LENGTH endif movwf tone_length bcf TRISA, AUDIO_OUT endm wait_count macro count ; attend que TMR2 est atteint le compte movlw count subwf TMR2,W skpc goto $-3 endm ; variables udata MINRAM disp res 42 ; mémoire bitmap affichage 16x21 pixels LScore res 1 ; pointage joueur de gauche RScore res 1 ; pointage joueur de droite flags res 1 ; indicateurs booléens ln_cnt res 1 ; compteur lignes scan NTSC, 9ième bit dans 'flags' ballx res 1 ; position horizontale de la balle bally res 1 ; position verticale de la balle dx res 1 ; delta x déplacement balle {-1,0,1} dy res 1 ; delta y déplacement balle {-1,0,1} ball_speed res 1 ; vitesse de la balle, multiple de 16,7msec tone_length res 1 ; durée de la tonalité btn_dly res 1 ; délais lecture boutons LPaddle res 1 ; position raquette joueur de gauche RPaddle res 1 ; position raquette joueur de droite temp res 1 ; 3 variables temporaires temp2 res 1 temp3 res 1 code org 0 rst_vector clrf OPTION_REG bsf WPUA, RA3 goto init org 4 isr_vector movlw 1 incf ln_cnt skpnz xorwf flags ; céduleur de tâche btfsc flags, F_VIDEO goto video_output btfss flags, F_BIT9 goto $+5 movlw 6 subwf ln_cnt, W skpnz goto sync_start movlw 1 subwf ln_cnt, W skpnz goto update_score movlw 3 subwf ln_cnt, W skpnz goto sync_end movlw 6 subwf ln_cnt, W skpnz goto move_ball movlw 7 subwf ln_cnt, W skpnz goto read_buttons movlw 29 subwf ln_cnt, W skpnz goto disp_start goto isr_exit ; aucune tâche à accomplir read_buttons btfsc flags, F_TONE goto isr_exit movf btn_dly, F skpnz call buttons goto isr_exit move_ball btfss flags, F_PAUSE call ball_control goto isr_exit video_output movlw 198 subwf ln_cnt, W skpnz goto disp_end call video goto isr_exit sync_start set_pwm_duty_cycle PWM_CH2, ((PWM_PERIOD<<2)-SYNC_WIDTH) movf ball_speed, F skpz decf ball_speed movf btn_dly, F skpz decf btn_dly, F btfss flags, F_TONE goto $+5 decfsz tone_length goto $+4 bcf flags, F_TONE disable_nco_output bsf TRISA, AUDIO_OUT clrf ln_cnt bcf flags, F_BIT9 call draw_table goto isr_exit sync_end set_pwm_duty_cycle PWM_CH2, SYNC_WIDTH goto isr_exit update_score call draw_score goto isr_exit disp_start bsf flags, F_VIDEO goto isr_exit disp_end bcf flags, F_VIDEO draw_side wait_count 67 goto $+1 ; délais supplémentaire bcf TRISA, VIDEO_OUT bsf PORTA, VIDEO_OUT wait_count 208 bcf PORTA, VIDEO_OUT bsf TRISA, VIDEO_OUT isr_exit bcf PIR1, TMR2IF retfie ; table des glyphes pour les caractères ; numérique, 2 digits compressés dans ; 5 octets digits addwf PCL, F dt H'44',H'AC',H'A4',H'A4',H'4E' ; 0, 1 dt H'EE',H'22',H'CC',H'82',H'EE' ; 2, 3 dt H'AE',H'A8',H'EE',H'22',H'2E' ; 4, 5 dt H'CE',H'82',H'E2',H'A2',H'E2' ; 6, 7 dt H'EE',H'AA',H'EE',H'A2',H'E6' ; 8, 9 ;****************************** ; video, génère la sortie vidéo ; entrée: disp est le bitmap ; contenant les pixels ; à afficher ;******************************* video movlw 30+40 subwf ln_cnt, W skpnz goto draw_side wait_count 48 movlw 30 subwf ln_cnt, W movwf FSR bcf TRISA, VIDEO_OUT movlw 8 movwf temp clrf temp2 clrc rrf FSR, F clrc rrf FSR, F bcf FSR, 0 ; début à l'octet pair movlw disp addwf FSR, F movfw INDF movwf temp3 pixel_loop rlf temp3, F rlf temp3, W andlw 1 addlw 2 movwf PORTA decfsz temp, F goto pixel_loop btfsc temp2, 0 goto video_exit bsf temp2, 0 incf FSR movfw INDF movwf temp3 movlw 8 bcf PORTA, VIDEO_OUT bsf PORTA, VIDEO_OUT movwf temp bcf PORTA, VIDEO_OUT goto pixel_loop video_exit delay_us 1 bcf PORTA, VIDEO_OUT bsf TRISA, VIDEO_OUT return ;*********************************** ; arrête l'action suite en attente ; du service ; les raquette sont placées à mi-hauteur ;*********************************** set_pause bsf flags, F_PAUSE movlw 7 movwf bally movlw 6 movwf LPaddle movwf RPaddle movlw 1 movwf ballx movwf dx btfss flags, F_SERVE return movlw 14 movwf ballx comf dx incf dx return ;********************************* ; bound_paddle, s'assure que les raquettes ; demeure dans les limites de la table ; entrée: W contient le pointeur de la raquette ; à vérifier ;***************************************** bound_paddle movwf FSR btfsc INDF, 7 clrf INDF movlw 14 subwf INDF, W skpz return movlw 13 movwf INDF return ;******************************** ; buttons, fait la lectures des boutons ; de contrôle du jeux. ; La lecture se fait dans l'intervalle ; ou l'affichage vidéo est inactif. ; la sortie vidéo (RA0) est utilisée pour ; contrôler quel boutons sont lus, i.e. ; gauche ou droite. ;********************************* buttons bcf flags, F_MOVED bcf PORTA, RA0 bcf TRISA, RA0 ; mode sortie delay_us 4 ; lecture boutons de droite movfw PORTA movwf temp ; lecture boutons de gauche bsf PORTA, RA0 delay_us 4 movfw PORTA movwf temp2 ; remet le port à l'état initial bsf TRISA, RA0 bcf PORTA, RA0 ; lecture boutons droites btfsc temp, RA3 goto $+4 decf RPaddle btfsc flags, F_SERVE bsf flags, F_MOVED btfsc temp, RA2 goto $+4 incf RPaddle btfsc flags, F_SERVE bsf flags, F_MOVED ; lecture boutons gauches btfsc temp2, RA3 goto $+4 decf LPaddle btfss flags, F_SERVE bsf flags, F_MOVED btfsc temp2, RA2 goto $+4 incf LPaddle btfss flags, F_SERVE bsf flags, F_MOVED ; libère si pause btfss flags, F_MOVED goto buttons_exit btfss flags, F_PAUSE goto buttons_exit bcf flags, F_PAUSE movfw dx addwf ballx buttons_exit movlw RPaddle call bound_paddle movlw LPaddle call bound_paddle return ;******************************** ; set_dy, détermine la valeur de dy ; si la balle est passé au dessus du centre de la raquette ; elle repart vers le haut (dy=-1) ; si la balle frappe la raquette au centre elle ; repart en ligne droite (dy=0) ; si elle est au dessous du centre elle repart ; vers le bas (dy=1) ; entrée: W = pointeur raquette qui a reçue la balle ;********************************* set_dy movwf FSR movfw INDF addlw 1 subwf bally, W skpnz return skpnc movlw -1 skpc movlw 1 movwf dy return ;******************************* ; ball_control, controle le mouvement ; de la balle en la faisant rebondir ; sur les raquettes et sur les bords ; haut et bas de la table. ;******************************* ball_control movf ball_speed, F skpz return movfw dy movwf temp movlw BALL_DLY movwf ball_speed movfw dx addwf ballx movfw dy addwf bally check_y_bounds skpnz goto invert_dy movlw 15 subwf bally, W skpc goto check_x_bounds invert_dy comf dy, F incf dy, F tone PING_TONE check_x_bounds movf ballx, F skpnz goto invert_dx movlw 15 subwf ballx,W skpz return invert_dx comf dx incf dx tone PING_TONE movf ballx, F skpnz goto check_left_collision ; a atteint le côté droit movfw RPaddle call set_dy movfw temp addwf RPaddle,W subwf bally, W skpc goto right_missed movlw 3 addwf RPaddle, W addwf temp, W subwf bally, W skpnc goto right_missed return check_left_collision ; a atteint le côté gauche movfw LPaddle call set_dy movfw temp addwf LPaddle,W subwf bally, W skpc goto left_missed movlw 3 addwf LPaddle, W addwf temp, W subwf bally, W skpnc goto left_missed return left_missed bsf flags, F_SCORE call player_score return right_missed bcf flags, F_SCORE call player_score return ;********************************* ; inc_score, incrémente le pointage ; du joueur qui a gagné l'échange. ; fait l'ajustement B.C.D. du compte. ; entrée: W contient le pointeur du ; joueur qui gagné l'échange. ;********************************** inc_score movwf FSR incf INDF movfw INDF andlw 15 sublw 9 skpnc return movlw H'F0' andwf INDF movlw H'10' addwf INDF movlw H'A0' subwf INDF,W skpnz clrf INDF return ;************************************ ; player_score, vérifie à qui va le point ; et appelle inc_score avec le pointeur ; du joueur gagnant. ; appel set_pause pour arrêter l'action ; en attente du prochain service. ;************************************* player_score bcf flags, F_SERVE btfss flags, F_SCORE ; 0 gauche, 1 droite goto left_score bsf flags, F_SERVE movlw RScore goto $+2 left_score movlw LScore call inc_score tone SCORE_TONE call set_pause return ;************************** ; draw_lpaddle, dessine la ; raquette de gauche ;************************** draw_lpaddle ; dessine raquette de gauche movlw disp+10 movwf FSR clrc rlf LPaddle, W addwf FSR movlw 128 goto draw_paddle ;**************************** ; draw_rpaddle, dessine la ; raquette de droite. ;**************************** draw_rpaddle ; dessine raquette de droite movlw disp+11 movwf FSR clrc rlf RPaddle, W addwf FSR movlw 1 draw_paddle iorwf INDF incf FSR incf FSR iorwf INDF incf FSR incf FSR iorwf INDF return ;**************************** ; draw_ball, dessine la balle ; sur la table ;**************************** draw_ball ; 24 cycles avec appel et retour movlw disp+10 ; les 10 premiers octets utilisé pour l'affichage du pointage movwf FSR clrc rlf bally, W ; 2 octets par ligne, donc déplacement = y*2 addwf FSR btfsc ballx, 3 ; si >7 incf FSR ; octet suivant movlw 128 ; position de la balle dans l'octet movwf temp ; rotation jusqu'à la bonne position movfw ballx andlw 7 ; W= compte des rotations skpnz goto $+6 clrc rrf temp addlw H'FF' ; W-- skpz goto $-4 movfw temp iorwf INDF, F return ;******************** ;clear_disp ;efface l'affichage ;******************** clear_disp ; 168 cycles avec appel et retour movlw disp movwf FSR movlw 42 movwf temp clrf INDF incf FSR decfsz temp goto $-3 return ;*********************** ; draw_table, dessine ; la table en appellant ; les routines pour chaque ; élément la composant. ;************************ draw_table ; 230 avec appel et retour call clear_disp ; 168 call draw_lpaddle ; 17 call draw_rpaddle ; 17 call draw_ball ; 24 return ; 2 ;*********************************** ; digit_offset, calcule la position ; position = digit * 10 / 2 ; dans la table 'digits' pour chaque digit ; entrée: W contient le digit dans ; les 4 bits faibles ; sortie: W contient le déplacement dans ; la table 'digits' ; utilise temp2 ;*********************************** digit_offset andlw H'E' movwf temp2 clrc rlf temp2, F rlf temp2, F addwf temp2, F rrf temp2, W return ;******************************************** ; digit_row, affiche une ligne des 2 digits ; du pointage. ; entrée: temp3, contient le pointage ; temp, contient la rangée du glyphe (0-5) ; utilise temp2 ;******************************************** digit_row swapf temp3, W ; digit dizaine call digit_offset addwf temp, W ; ajoute déplacement pour la rangée call digits movwf temp2 ; bitmap pour cette rangée btfsc temp3, 4 ; si digit pair prend les 4 bits forts swapf temp2, W ; si impair prend les 4 bits faibles. andlw H'F0' iorwf INDF digit2 ; digit unités movfw temp3 call digit_offset addwf temp, W call digits movwf temp2 btfss temp3, 0 swapf temp2, W andlw H'F' iorwf INDF return ;*********************************** ; draw_score, affiche les glyphes du pointage ; de chaque joueur. L'affichage se fait par ; rangée, i.e. la première rangée des 4 glyphes ; est affichée ensuite la 2ième, etc. ; utilse: temp comme compteur de rangée ; temp3 contient le pointage ; FSR pointe la mémoire vidéo 'disp' ;************************************ draw_score movlw disp movwf FSR clrf temp ; compteur lignes du glyphe next_row movfw LScore movwf temp3 call digit_row incf FSR movfw RScore movwf temp3 call digit_row incf FSR incf temp movlw 5 subwf temp,W skpz goto next_row return ; initialiation du programme. init set_clk_freq D'16' clrf ANSELA ; zero RAM movlw MINRAM movwf FSR clrf INDF incf FSR btfss FSR, 7 goto $-3 ; initialisation NCO set_nco_clock NCO_CLK_INTOSC enable_nco ; initialisation PWM1 movlw PWM_PERIOD movwf PR2 bcf TRISA, SYNC_OUT set_pwm_polarity PWM_CH2, PWM_POL_L enable_pwm_output PWM_CH2 enable_pwm_channel PWM_CH2 enable_tmr2_int enable_periph_int call set_pause bsf T2CON, TMR2ON enable_interrupt ; il ne se passe rien dans la procédure ; principale car tout est fait pendant ; l'interruption du TIMER2 main goto main end

Il a fallu que le code soit analysé minutieusement en accordant la priorité à la réduction de sa taille pour réussir à le faire entrer dans cette espace limité. J'ai eu plusieurs échecs de compilation part manque d'espace avant de réussir à caser le programme dans cet espace restreint.

Au démarrage le joueur de gauche a le service. On peut identifier le joueur qui a le service par la balle placée au centre de sa raquette. Pour faire le service le joueur doit déplacer sa raquette dans une direction ou l'autre. Lors de l'échange un joueur peut modifier la trajectoire de la balle en positionnant sa raquette pour que la collision avec la balle se fasse à un endroit différent de la raquette. Les raquettes on 3 pixels en hauteur. Si la balle atteint le pixel du haut la balle repart à 45 degrés vers le haut. Si la balle frappe la raquette au centre elle repart à l'horizontal. Si elle frappe sur le pixel du bas elle repart à 45 degrés vers le bas. Pour modifier la vitesse de la balle il faut changer la valeur de BALL_DLY. Pour changer la vitesse de déplacement des raquettes il faut changer la valeur de BTN_DLY.