Etude des cartes audio MA-55

; ----------------------------------------------------------------------------------------------------------- ; GOTTLIEB SYSTEM 80 ; Reverse engeenering sur carte son 6503 + 6530 ; Copyright 2015 - Flipprojets - François et Thierry DAVROUX ; ----------------------------------------------------------------------------------------------------------- ; PROM son (Harris) de 1024 x 4 bits - pour le flipper PANTHERA ; (pour inclusion dans le programme principal). ; ; La PROM son est décodée sur l'espace $400-$7FF. ; ----------------------------------------------------------------------------------------------------------- ; --------------------------------------------------------------------------------------------------- ; Macro pour les tables d'adresses sur 3 x 4 bits (le quartet de poids fort est en premier) ; --------------------------------------------------------------------------------------------------- Adresse .MACRO Adr ; Pour une adresse $XXX : .DB >%1 ; Premier quartet $X-- .DB <%1/16 ; Deuxième quartet $-X- .DB [<%1 & $0F] ; Troisième quartet $--X .ENDM ; --------------------------------------------------------------------------------------------------- ; Structure et codage de la PROM ; ; Au début de la PROM, il y a des tables d'adresses, chaque entrée utilisant trois quartets ; (3 x 4 bits) pour coder une adresse sur 12 bits. Les quartets sont dans l'ordre normal (poids fort ; en premier). ; --------------------------------------------------------------------------------------------------- .ORG $400 ; ------------------------------------------------------- ; Table des adresses des sons ; Pour chaque commande reçue (numéro de son de 1 à 15), ; il y a une ligne dans la table, faisant 3 quartets. Ce ; qui correspond à une adresse dans la PROM. ; ------------------------------------------------------- Adresse Tone_00 ; 0 -> $4A0 - Adresse son 0 - Attract et test Adresse Tone_01 ; 1 -> $4A0 - Adresse son 1 (commande 1) en mode tone Adresse Tone_02 ; 2 -> $64F - Adresse son 2 (commande 2) en mode tone Adresse Tone_03 ; 3 -> $4A0 - Adresse son 3 (commande 3) en mode tone (idem son 1) Adresse Tone_04 ; 4 -> $5A1 - Adresse son 4 (commande 4) en mode tone Adresse Tone_05 ; 5 -> $581 - Adresse son 5 (commande 5) en mode tone Adresse Tone_06 ; 6 -> $760 - Adresse son 6 (commande 6) en mode tone Adresse Tone_07 ; 7 -> $478 - Adresse son 7 (commande 7) en mode tone Adresse Tone_08 ; 8 -> $45F - Adresse son 8 (commande 8) en mode tone Adresse Tone_09 ; 9 -> $73F - Adresse son 9 (commande 9) en mode tone Adresse Tone_10 ; A -> $5BF - Adresse son 10 (commande 10) en mode tone Adresse Tone_11 ; B -> $71F - Adresse son 11 (commande 11) en mode tone Adresse Tone_12 ; C -> $4EF - Adresse son 12 (commande 12) en mode tone Adresse Tone_13 ; D -> $45F - Adresse son 13 (commande 13) en mode tone (idem son 8) Adresse Tone_14 ; E -> $64F - Adresse son 14 (commande 14) en mode tone (idem son 2) Adresse Tone_15 ; F -> $50F - Adresse son 15 (commande 15) en mode tone Adresse Sound_01 ; 81 -> $4A1 - Adresse son 1 (commande 1) en mode sound Adresse Sound_02 ; 82 -> $650 - Adresse son 2 (commande 2) en mode sound Adresse Sound_03 ; 83 -> $4A1 - Adresse son 3 (commande 3) en mode sound (idem son 1) Adresse Sound_04 ; 84 -> $5A0 - Adresse son 4 (commande 4) en mode sound Adresse Sound_05 ; 85 -> $580 - Adresse son 5 (commande 5) en mode sound Adresse Sound_06 ; 86 -> $600 - Adresse son 6 (commande 6) en mode sound Adresse Sound_07 ; 87 -> $530 - Adresse son 7 (commande 7) en mode sound Adresse Sound_08 ; 88 -> $460 - Adresse son 8 (commande 8) en mode sound Adresse Sound_09 ; 89 -> $740 - Adresse son 9 (commande 9) en mode sound Adresse Sound_10 ; 8A -> $5C0 - Adresse son 10 (commande 10) en mode sound Adresse Sound_11 ; 8B -> $720 - Adresse son 11 (commande 11) en mode sound Adresse Sound_12 ; 8C -> $4F0 - Adresse son 12 (commande 12) en mode sound Adresse Sound_13 ; 8D -> $460 - Adresse son 13 (commande 13) en mode sound (idem son 8) Adresse Sound_14 ; 8E -> $650 - Adresse son 14 (commande 14) en mode sound (idem son 2) Adresse Sound_15 ; 8F -> $510 - Adresse son 15 (commande 15) en mode sound ; ----------------------------------------------------------------------------------- ; Paramètres des sons (macro-langage SGOL) à partir de $45D ; Les zones "filler" sont inutilisées et peuvent êtres remplies avec n'importe quoi ! ; ----------------------------------------------------------------------------------- Filler_45D: .DB $C, $B ; //////////////////////////////////////////////////// Tone_08: ; ---> Son 8 en mode Tone Tone_13: ; ---> Son 13 en mode Tone (idem son 8) ; (45F) .DB $D ; INS D - MODE (force le mode SOUND) Sound_08: ; ---> Son 8 en mode Sound Sound_13: ; ---> Son 13 en mode Sound (idem son 8) ; (460) .DB $E, $2, $F ; INS E - REPEAT 3, 15 (Boucle 15 fois les 3 instructions) .DB $7, $7, $C, $0, $0, $8, $0 ; * INS 7 - SOUND ... .DB $7, $7, $C, $0, $0, $4, $0 ; * INS 7 - SOUND ... .DB $7, $7, $C, $0, $0, $8, $0 ; * INS 7 - SOUND ... Tone_07: ; ---> Son 07 en mode Tone ; (478) .DB $F ; INS F - END Filler_479: .DB $4, $0, $6, $4, $0, $F, $4 ; //////////////////////////////////////////////////// .DB $7, $B, $D, $0, $0, $E, $0, $F ; //////////////////////////////////////////////////// .DB $9, $C, $7, $1, $4, $0, $F, $9 ; //////////////////////////////////////////////////// .DB $7, $D, $C, $0, $0, $4, $0, $F ; //////////////////////////////////////////////////// .DB $8, $D, $4, $8, $F, $4, $C, $F ; //////////////////////////////////////////////////// Tone_00: ; ---> Son 0 pour le mode test et l'attract mode (idem son 1) Tone_01: ; ---> Son 1 en mode Tone Tone_03: ; ---> Son 3 en mode Tone (idem son 1) ; (4A0) .DB $D ; INS D - MODE (force le mode SOUND) Sound_01: ; ---> Son 1 en mode Sound Sound_03: ; ---> Son 3 en mode Sound (idem son 1) ; (4A1) .DB $8 ; INS 8 - NOP .DB $7, $F, $B, $5, $5, $A, $0 ; INS 7 - SOUND ... .DB $F ; INS F - END Filler_4AA: .DB $4, $8, $F, $C, $0, $8 ; //////////////////////////////////////////////////// .DB $C, $E, $1, $8, $7, $9, $C, $B ; //////////////////////////////////////////////////// .DB $6, $E, $0, $7, $9, $C, $B, $6 ; //////////////////////////////////////////////////// .DB $E, $0, $F, $1, $A, $1, $6, $2 ; //////////////////////////////////////////////////// .DB $3, $1, $4, $8, $0, $0, $C, $6 ; //////////////////////////////////////////////////// .DB $C, $8, $8, $8, $7, $B, $C, $7 ; //////////////////////////////////////////////////// .DB $B, $E, $0, $7, $9, $C, $0, $0 ; //////////////////////////////////////////////////// .DB $E, $0, $7, $B, $C, $7, $B, $E ; //////////////////////////////////////////////////// .DB $0, $F, $1, $C, $C, $0, $0 ; //////////////////////////////////////////////////// Tone_12: ; ---> Son 12 en mode Tone ; (4EF) .DB $D ; INS D - MODE (force le mode SOUND) Sound_12: ; ---> Son 12 en mode Sound ; (4F0) .DB $E, $2, $F ; INS E - REPEAT 3, 15 (Boucle 15 fois les 3 instructions) .DB $7, $7, $0, $A, $5, $E, $0 ; * INS 7 - SOUND ... .DB $7, $2, $0, $0, $0, $9, $0 ; * INS 7 - SOUND ... .DB $7, $7, $0, $A, $5, $E, $0 ; * INS 7 - SOUND ... .DB $F ; INS F - END Filler_509: .DB $C, $4, $C, $C, $F, $F ; //////////////////////////////////////////////////// Tone_15: ; ---> Son 15 en mode Tone ; (50F) .DB $D ; INS D - MODE (force le mode SOUND) Sound_15: ; ---> Son 15 en mode Sound ; (510) .DB $C ; INS C - PRIOTITY .DB $E, $2, $3 ; INS E - REPEAT 3, 3 (Boucle 3 fois les 3 instructions) .DB $7, $D, $C, $0, $E, $A, $0 ; * INS 7 - SOUND ... .DB $7, $8, $C, $0, $0, $A, $0 ; * INS 7 - SOUND ... .DB $0, $0, $B, $0, $0 ; * INS 0 - SOUND ... .DB $D ; INS D - MODE (passe en mode TONE) .DB $7, $0, $0 ; INS 7 - TONE ... .DB $F ; INS F - END Filler_52C: .DB $E, $C, $6, $6 ; //////////////////////////////////////////////////// Sound_07: ; ---> Son 7 en mode Sound ; (530) .DB $7, $5, $D, $0, $0, $A, $3 ; INS 7 - SOUND ... .DB $4, $4, $3, $0, $0 ; INS 4 - SOUND ... .DB $D ; INS D - MODE (passe en mode TONE) .DB $7, $0, $8 ; INS 7 - TONE ... .DB $D ; INS D - MODE (retour au mode SOUND) .DB $7, $5, $D, $8, $0, $C, $7 ; INS 7 - SOUND ... .DB $2, $4, $3, $0, $0 ; INS 2 - SOUND ... .DB $D ; INS D - MODE (passe en mode TONE) .DB $7, $0, $7 ; INS 7 - TONE ... .DB $8 ; INS 8 - NOP .DB $D ; INS D - MODE (retour au mode SOUND) .DB $7, $5, $D, $8, $0, $C, $4 ; INS 7 - SOUND ... .DB $2, $4, $3, $0, $0 ; INS 2 - SOUND ... .DB $D ; INS D - MODE (passe en mode TONE) .DB $7, $0, $9 ; INS 7 - TONE ... .DB $D ; INS D - MODE (retour au mode SOUND) .DB $7, $5, $D, $8, $0, $C, $4 ; INS 7 - SOUND ... .DB $2, $4, $3, $0, $0 ; INS 2 - SOUND ... .DB $F ; INS F - END Filler_571: .DB $A, $A, $2, $2, $1, $2, $A ; //////////////////////////////////////////////////// .DB $A, $A, $6, $2, $A, $0, $7, $6 ; //////////////////////////////////////////////////// Tone_05: ; ---> Son 5 en mode Tone ; (580) .DB $D ; INS D - MODE (force le mode SOUND) Sound_05: ; ---> Son 5 en mode Sound ; (581) .DB $4, $4, $A, $2, $6 ; INS 4 - SOUND ... .DB $A ; INS A .DB $4, $6, $A, $2, $8 ; INS 4 - SOUND ... .DB $A ; INS A .DB $4, $8, $A, $2, $A ; INS 4 - SOUND ... .DB $A ; INS A .DB $4, $A, $A, $2, $C ; INS 4 - SOUND ... .DB $A ; INS A .DB $F ; INS F - END Filler_59A: .DB $6, $7, $A, $7, $C, $C ; //////////////////////////////////////////////////// Tone_04: ; ---> Son 4 en mode Tone ; (5A0) .DB $D ; INS D - MODE (force le mode SOUND) Sound_04: ; ---> Son 4 en mode Sound ; (5A1) .DB $4, $A, $8, $2, $A ; INS 4 - SOUND ... .DB $8 ; INS 8 - NOP .DB $4, $8, $8, $2, $A ; INS 4 - SOUND ... .DB $8 ; INS 8 - NOP .DB $2, $6, $6, $F, $2 ; INS 2 - SOUND ... .DB $2, $1, $0, $0, $A ; INS 2 - SOUND ... .DB $E, $C, $2 ; INS E - REPEAT 13, 2 (Boucle infinie) .DB $0, $0, $E, $8, $6 ; * INS 0 - SOUND ... Tone_10: ; ---> Son 10 en mode Tone ; (5BF) .DB $D ; INS D - MODE (force le mode SOUND) Sound_10: ; ---> Son 10 en mode Sound ; (5C0) .DB $7, $7, $D, $0, $0, $6, $0 ; INS 7 - SOUND ... .DB $7, $7, $D, $0, $0, $4, $0 ; INS 7 - SOUND ... .DB $E, $2, $4 ; INS E - REPEAT 3, 4 (Boucle 4 fois les 3 instructions) .DB $7, $7, $D, $4, $0, $2, $0 ; * INS 7 - SOUND ... .DB $7, $7, $D, $0, $0, $0, $0 ; * INS 7 - SOUND ... .DB $7, $7, $D, $0, $0, $2, $0 ; * INS 7 - SOUND ... .DB $7, $7, $D, $0, $0, $4, $0 ; INS 7 - SOUND ... .DB $7, $7, $D, $0, $0, $6, $0 ; INS 7 - SOUND ... .DB $7, $7, $D, $0, $0, $8, $0 ; INS 7 - SOUND ... .DB $F ; INS F - END Filler_5FC: .DB $F, $2, $F, $A ; //////////////////////////////////////////////////// Sound_06: ; ---> Son 06 en mode Sound ; (600) .DB $B ; INS B .DB $2, $6, $4, $0, $6 ; INS 2 - SOUND ... .DB $3, $6, $4, $0, $6 ; INS 3 - SOUND ... .DB $6, $6, $4, $0, $6 ; INS 6 - SOUND ... .DB $4, $7, $4, $0, $6 ; INS 4 - SOUND ... .DB $5, $7, $4, $0, $6 ; INS 5 - SOUND ... .DB $0, $7, $4, $0, $6 ; INS 0 - SOUND ... .DB $2, $8, $4, $0, $6 ; INS 2 - SOUND ... .DB $3, $8, $4, $0, $6 ; INS 3 - SOUND ... .DB $6, $8, $4, $0, $6 ; INS 6 - SOUND ... .DB $4, $9, $4, $0, $6 ; INS 4 - SOUND ... .DB $5, $9, $4, $0, $6 ; INS 5 - SOUND ... .DB $0, $9, $4, $0, $6 ; INS 0 - SOUND ... .DB $2, $A, $4, $0, $6 ; INS 2 - SOUND ... .DB $3, $A, $4, $0, $6 ; INS 3 - SOUND ... .DB $6, $A, $4, $0, $6 ; INS 6 - SOUND ... .DB $A ; INS A .DB $F ; INS F - END Filler_64E: .DB $F ; //////////////////////////////////////////////////// Tone_02: ; ---> Son 2 en mode Tone Tone_14: ; ---> Son 14 en mode Tone (idem son 2) ; (64F) .DB $D ; INS D - MODE (force le mode SOUND) Sound_02: ; ---> Son 2 en mode Sound Sound_14: ; ---> Son 14 en mode Sound (idem son 2) ; (650) .DB $C ; INS C - PRIORITY .DB $E, $6, $4 ; INS E - REPEAT 7, 4 (Boucle 4 fois les 7 instructions) .DB $7, $B, $C, $0, $0, $0, $2 ; * INS 7 - SOUND ... .DB $7, $D, $C, $0, $0, $1, $4 ; * INS 7 - SOUND ... .DB $7, $B, $C, $0, $0, $0, $2 ; * INS 7 - SOUND ... .DB $7, $F, $F, $8, $F, $0, $6 ; * INS 7 - SOUND ... .DB $7, $B, $C, $0, $0, $0, $2 ; * INS 7 - SOUND ... .DB $7, $D, $D, $0, $0, $1, $4 ; * INS 7 - SOUND ... .DB $7, $B, $C, $0, $0, $0, $2 ; * INS 7 - SOUND ... .DB $F ; INS F - END Filler_686: .DB $F, $F ; //////////////////////////////////////////////////// .DB $F, $F, $F, $F, $F, $F, $F, $F ; //////////////////////////////////////////////////// .DB $C, $E, $3, $8, $5, $A, $8, $0 ; //////////////////////////////////////////////////// .DB $3, $2, $A, $8, $0, $3, $5, $8 ; //////////////////////////////////////////////////// .DB $8, $0, $3, $5, $2, $1, $0, $5 ; //////////////////////////////////////////////////// .DB $E, $2, $8, $7, $6, $C, $0, $4 ; //////////////////////////////////////////////////// .DB $A, $4, $7, $6, $C, $1, $5, $A ; //////////////////////////////////////////////////// .DB $4, $7, $6, $C, $0, $4, $A, $4 ; //////////////////////////////////////////////////// .DB $F, $F, $F, $F, $F, $F, $F, $F ; //////////////////////////////////////////////////// .DB $F, $F, $F, $F, $F, $F, $F, $F ; //////////////////////////////////////////////////// .DB $7, $D, $C, $0, $0, $A, $8, $5 ; //////////////////////////////////////////////////// .DB $6, $9, $0, $3, $E, $2, $8, $5 ; //////////////////////////////////////////////////// .DB $6, $9, $0, $3, $2, $8, $9, $0 ; //////////////////////////////////////////////////// .DB $3, $2, $6, $9, $0, $3, $5, $6 ; //////////////////////////////////////////////////// .DB $9, $0, $3, $5, $4, $9, $0, $3 ; //////////////////////////////////////////////////// .DB $2, $6, $9, $0, $3, $2, $4, $9 ; //////////////////////////////////////////////////// .DB $0, $3, $5, $4, $9, $0, $3, $5 ; //////////////////////////////////////////////////// .DB $2, $9, $0, $3, $2, $4, $9, $0 ; //////////////////////////////////////////////////// .DB $3, $2, $2, $9, $0, $3, $F, $F ; //////////////////////////////////////////////////// .DB $F, $F, $F, $F, $F, $F, $F ; //////////////////////////////////////////////////// Tone_11: ; ---> Son 11 en mode Tone ; (71F) .DB $D ; INS D - MODE (force le mode SOUND) Sound_11: ; ---> Son 11 en mode Sound ; (720) .DB $E, $1, $F ; INS E - REPEAT 2, 15 ; (Boucle 15 fois les 2 instructions suivantes) .DB $7, $5, $D, $0, $0, $E, $0 ; * INS 7 - SOUND ... .DB $7, $5, $D, $0, $0, $E, $0 ; * INS 7 - SOUND ... .DB $F ; INS F - END Filler_732: .DB $F, $D, $F, $F, $F, $D ; //////////////////////////////////////////////////// .DB $F, $E, $7, $F, $F, $F, $F ; //////////////////////////////////////////////////// Tone_09 ; ---> Son 9 en mode Tone ; (73F) .DB $D ; INS D - MODE (force le mode SOUND) Sound_09 ; ---> Son 9 en mode Sound ; (740) .DB $C ; INS C .DB $E, $1, $2 ; INS E - REPEAT 2, 2 ; (Boucle 2 fois les 2 instructions suivantes) .DB $7, $B, $D, $0, $0, $E, $0 ; * INS 7 - SOUND ... .DB $7, $B, $D, $0, $0, $E, $0 ; * INS 7 - SOUND ... .DB $F ; INS F - END Filler_753: .DB $F, $F, $F, $F, $F ; //////////////////////////////////////////////////// .DB $F, $F, $F, $F, $F, $F, $F, $F ; //////////////////////////////////////////////////// Tone_06 ; ---> Son 06 en mode Tone ; (760) .DB $B ; INS B .DB $D ; INS D .DB $2, $6, $4, $0, $6 ; INS 2 - SOUND ... .DB $D ; INS D .DB $3, $6, $4, $0, $6 ; INS 3 - SOUND ... .DB $D ; INS D .DB $6, $6, $4, $0, $6 ; INS 6 - SOUND ... .DB $D ; INS D .DB $4, $7, $4, $0, $6 ; INS 4 - SOUND ... .DB $D ; INS D .DB $5, $7, $4, $0, $6 ; INS 5 - SOUND ... .DB $D ; INS D .DB $0, $7, $4, $0, $6 ; INS 0 - SOUND ... .DB $D ; INS D .DB $2, $8, $4, $0, $6 ; INS 2 - SOUND ... .DB $D ; INS D .DB $3, $8, $4, $0, $6 ; INS 3 - SOUND ... .DB $D ; INS D .DB $6, $8, $4, $0, $6 ; INS 6 - SOUND ... .DB $D ; INS D .DB $4, $9, $4, $0, $6 ; INS 4 - SOUND ... .DB $D ; INS D .DB $5, $9, $4, $0, $6 ; INS 5 - SOUND ... .DB $D ; INS D .DB $0, $9, $4, $0, $6 ; INS 0 - SOUND ... .DB $D ; INS D .DB $2, $A, $4, $0, $6 ; INS 2 - SOUND ... .DB $D ; INS D .DB $3, $A, $4, $0, $6 ; INS 3 - SOUND ... .DB $D ; INS D .DB $6, $A, $4, $0, $6 ; INS 6 - SOUND ... .DB $A ; INS A .DB $F ; INS F - END Filler_7BD: .DB $4, $2, $4 ; //////////////////////////////////////////////////// ; Table particulière en fin de la PROM ; en $7C0 e7C0: .DB $E, $1, $6, $3, $5, $6, $4, $2 e7C8: .DB $0, $1, $8, $0, $5, $C, $B, $0 e7D0: .DB $E, $0, $D, $7, $3, $8, $F, $F e7D8: .DB $F, $F, $F, $1, $0, $C, $7, $3 e7E0: .DB $8, $0, $1, $2, $2, $F, $A, $1 e7E8: .DB $0, $5, $5, $0, $8, $9, $8, $8 e7F0: .DB $D, $2, $D, $D, $2, $0, $5, $8 e7F8: .DB $D, $6, $3, $8, $C, $4, $5, $2 .END

; ----------------------------------------------------------------------------------------------------------- ; GOTTLIEB SYSTEM 80 ; Reverse engeenering sur carte son 6503 + 6530 ; Copyright 2015 - Flipprojets - François et Thierry DAVROUX ; ----------------------------------------------------------------------------------------------------------- ; PROM son (Harris) de 1024 x 4 bits - pour le flipper PINK PANTHER ; (pour inclusion dans le programme principal). ; ; La PROM son est décodée sur l'espace $400-$7FF. ; ----------------------------------------------------------------------------------------------------------- ; --------------------------------------------------------------------------------------------------- ; Macro pour les tables d'adresses sur 3 x 4 bits (le quartet de poids fort est en premier) ; --------------------------------------------------------------------------------------------------- Adresse .MACRO Adr ; Pour une adresse $XXX : .DB >%1 ; Premier quartet $X-- .DB <%1/16 ; Deuxième quartet $-X- .DB [<%1 & $0F] ; Troisième quartet $--X .ENDM ; --------------------------------------------------------------------------------------------------- ; Structure et codage de la PROM ; ; Au début de la PROM, il y a des tables d'adresses, chaque entrée utilisant trois quartets ; (3 x 4 bits) pour coder une adresse sur 12 bits. Les quartets sont dans l'ordre normal (poids fort ; en premier). ; --------------------------------------------------------------------------------------------------- .ORG $400 ; ------------------------------------------------------- ; Table des adresses des sons ; Pour chaque commande reçue (numéro de son de 1 à 15), ; il y a une ligne dans la table, faisant 3 quartets. Ce ; qui correspond à une adresse dans la PROM. ; ------------------------------------------------------- Adresse Tone_00 ; 0 -> $550 - Adresse son 0 - Attract et test ; ------------------------------------------------------- ; Séquence ASM 6503 - 45 octets / 90 quartets ; ------------------------------------------------------- ; Chargée en spécifiant l'adresse $3CC ; ------------------------------------------------------- ; LDX #$03 ; STX z08 ; LDX #$7D ; STX z0C ; LDX #$06 ; STX z0D ; LDA #$06 ; LDX #$91 ; JMP a0E23 ; --> continue en $691 ; // BUG // ; Adresse érronée -> $E26 ; ; (JMP External_Load) ; ; ($403) ; --------------------------------------------------------- .DB $0, $E, $2, $3, $4, $C ; JMP a0E23 .DB $9, $1, $A, $2 ; LDX #$91 .DB $0, $6, $A, $9 ; LDA #$06 .DB $0, $D, $8, $6 ; STX z0D .DB $0, $6, $A, $2 ; LDX #$06 .DB $0, $C, $8, $6 ; STX z0C .DB $7, $D, $A, $2 ; LDX #$7D .DB $0, $8, $8, $6 ; STX z08 .DB $0, $3, $A, $2 ; LDX #$03 .DB $0 .DB $6, $4, $6 .DB $E, $0, $0 Adresse Sound_01 ; 81 -> $54E - Adresse son 1 (commande 1) en mode sound Adresse Sound_02 ; 82 -> $5A8 - Adresse son 2 (commande 2) en mode sound Adresse Sound_03 ; 83 -> $61F - Adresse son 3 (commande 3) en mode sound Adresse Sound_04 ; 84 -> $792 - Adresse son 4 (commande 4) en mode sound Adresse Sound_05 ; 85 -> $5A8 - Adresse son 5 (commande 5) en mode sound (idem son 2) Adresse Sound_06 ; 86 -> $45D - Adresse son 6 (commande 6) en mode sound Adresse Sound_07 ; 87 -> $45D - Adresse son 7 (commande 7) en mode sound (idem son 6) Adresse Sound_08 ; 88 -> $45D - Adresse son 8 (commande 8) en mode sound (idem son 6) Adresse Sound_09 ; 89 -> $45D - Adresse son 9 (commande 9) en mode sound (idem son 6) Adresse Sound_10 ; 8A -> $45D - Adresse son 10 (commande 10) en mode sound (idem son 6) Adresse Sound_11 ; 8B -> $45D - Adresse son 11 (commande 11) en mode sound (idem son 6) Adresse Sound_12 ; 8C -> $45D - Adresse son 12 (commande 12) en mode sound (idem son 6) Adresse Sound_13 ; 8D -> $45D - Adresse son 13 (commande 13) en mode sound (idem son 6) Adresse Sound_14 ; 8E -> $531 - Adresse son 14 (commande 14) en mode sound Adresse Sound_15 ; 8F -> $61F - Adresse son 15 (commande 15) en mode sound (idem son 3) Sound_06: ; ---> Son 6 en mode Sound Sound_07: ; ---> Son 7 en mode Sound Sound_08: ; ---> Son 8 en mode Sound Sound_09: ; ---> Son 9 en mode Sound Sound_10: ; ---> Son 10 en mode Sound Sound_11: ; ---> Son 11 en mode Sound Sound_12: ; ---> Son 12 en mode Sound Sound_13: ; ---> Son 13 en mode Sound ; (45D) .DB $E, $0, $0 ; INS E 0 0 --> appel code 6503 (adresse 702) ; Table d'adresses pour code externe 6503 ; selon code du son (80 à 8F) e460: .DB $0, $0, $0, $0 ; /// Sound 0 (non utilisé) .DB $0, $5, $C, $3 ; /// Sound 1 (non utilisé) .DB $0, $5, $E, $9 ; /// Sound 2 (non utilisé) .DB $0, $0, $0, $0 ; /// Sound 3 (non utilisé) .DB $0, $6, $0, $5 ; /// Sound 4 (non utilisé) .DB $0, $0, $0, $0 ; /// Sound 5 (non utilisé) .DB $0, $3, $C, $C ; --> Sound 6 ==> Load code $3CC .DB $0, $5, $B, $8 ; --> Sound 7 ==> Load code $5B8 .DB $0, $6, $7, $1 ; --> Sound 8 ==> Load code $671 .DB $0, $5, $F, $5 ; --> Sound 9 ==> Load code $5F5 .DB $0, $6, $3, $B ; --> Sound 10 ==> Load code $63B .DB $0, $5, $9, $2 ; --> Sound 11 ==> Load code $592 .DB $0, $6, $A, $9 ; --> Sound 12 ==> Load code $6A9 .DB $0, $7, $3, $5 ; --> Sound 13 ==> Load code $735 .DB $7, $E, $F, $0 ; /// Sound 14 (non utilisé) .DB $0, $8, $0, $F ; /// Sound 15 (non utilisé) ; ------------------------------------------------------- ; Séquence ASM 6503 - 45 octets / 90 quartets ; ------------------------------------------------------- ; Chargée en spécifiant l'adresse $497 ; ------------------------------------------------------- ;e0010: ; LDX z08 ;e0012: ; LDY z0E ;e0014: ; LDA z00,X ; STA PORTA ; DEY ; BNE e0014 ; DEX ; BPL e0012 ; LDA PORTB ; AND #$0F ; BEQ e002A ; CMP z0D ; BNE e0037 ;e002A: ; LDA z0E ; CLC ; ADC z0C ; STA z0E ; DEC z01 ; DEC z03 ; BNE e0010 ;e0037: ; JMP ProgramInit ; ; ($4A0) ; --------------------------------------------------------- .DB $0, $D, $1, $6, $4, $C ; JMP a0D16 .DB $D, $9, $D, $0 ; BNE e0010 .DB $0, $3, $C, $6 ; DEC z03 .DB $0, $1, $C, $6 ; DEC z01 .DB $0, $E, $8, $5 ; STA z0E .DB $0, $C, $6, $5 ; ADC z0C .DB $1, $8 ; CLC .DB $0, $E, $A, $5 ; LDA z0E .DB $0, $D, $D, $0 ; BNE e0037 .DB $0, $D, $C, $5 ; CMP z0D .DB $0, $4, $F, $0 ; BEQ e002A .DB $0, $F, $2, $9 ; AND #$0F .DB $0, $2, $0, $2, $A, $D ; LDA a0202 .DB $F, $3, $1, $0 ; BPL e0012 .DB $C, $A ; DEX .DB $F, $8, $D, $0 ; BNE e0014 .DB $8, $8 ; DEY .DB $0, $2, $0, $0, $8, $D ; STA a0200 .DB $0, $0, $B, $5 ; LDA z00,X .DB $0, $E, $A, $4 ; LDY z0E .DB $0, $8, $A, $6 ; LDX z08 ; ------------------------------------------------------- ; Séquence ASM 6503 - 45 octets / 90 quartets ; ------------------------------------------------------- ; Chargée en spécifiant l'adresse $4F1 ; ------------------------------------------------------- ;e0010: ; LDY z01 ;e0012: ; LDX z02 ; LDA a0F84,Y ; STA PORTA ; LDA PORTB ; AND #$0F ; BEQ e0025 ; CMP z05 ; BNE e003A ;e0025: ; DEX ; BNE e0025 ; DEY ; BPL e0012 ; CLC ; LDA z02 ; ADC z03 ; STA z02 ; BNE e0010 ; DEC z03 ; DEC z00 ; BNE e0010 ;e003A: ; JMP ProgramInit ; ; ($4F4) ; --------------------------------------------------------- .DB $0, $D, $1, $6, $4, $C ; JMP a0D16 .DB $D, $6, $D, $0 ; BNE e0010 .DB $0, $0, $C, $6 ; DEC z03 .DB $0, $3, $C, $6 ; DEC z00 .DB $D, $C, $D, $0 ; BNE e0010 .DB $0, $2, $8, $5 ; STA z02 .DB $0, $3, $6, $5 ; ADC z03 .DB $0, $2, $A, $5 ; LDA z02 .DB $1, $8 ; CLC .DB $E, $7, $1, $0 ; BPL e0012 .DB $8, $8 ; DEY .DB $F, $D, $D, $0 ; BNE e0025 .DB $C, $A ; DEX .DB $1, $5, $D, $0 ; BNE e003A .DB $0, $5, $C, $5 ; CMP z05 .DB $0, $4, $F, $0 ; BEQ e0025 .DB $0 ; (AND #$0F -> voir suite après) Sound_14: ; ---> Son 14 en mode Sound ; (531) .DB $F ; INS F ; Ne fait rien, mais erreur de programmation car le ; code SGOL tombe en plein milieu d'une sequence ; assembleur. Bug sans conséquence. e532: .DB $2, $9 ; AND #$0F .DB $0, $2, $0, $2, $A, $D ; LDA a0202 .DB $0, $2, $0, $0, $8, $D ; STA a0200 .DB $0, $F, $8, $4, $B, $9 ; LDA a0F84,Y .DB $0, $2, $A, $6 ; LDX z02 .DB $0, $1, $A, $4 ; LDY z01 Sound_01: ; ---> Son 1 en mode Sound ; (54E) .DB $D ; INS D .DB $C ; INS C Tone_00: ; ---> Son 0 pour le mode test et l'attract mode ; (550) = musique de la panthère rose .DB $2, $8, $6 ; INS 2 .DB $3, $9, $4 ; INS 3 .DB $6, $8, $6 ; INS 6 .DB $4, $8, $6 ; INS 4 .DB $7, $0, $2 ; INS 7 .DB $5, $8, $6 ; INS 5 .DB $5, $9, $6 ; INS 5 .DB $7, $0, $2 ; INS 7 .DB $6, $8, $6 ; INS 6 .DB $4, $8, $4 ; INS 4 .DB $5, $8, $6 ; INS 5 .DB $5, $9, $4 ; INS 5 .DB $2, $B, $6 ; INS 2 .DB $2, $A, $6 ; INS 2 .DB $0, $9, $A ; INS 0 .DB $0, $8, $A ; INS 0 .DB $5, $9, $A ; INS 5 .DB $5, $8, $A ; INS 5 .DB $4, $8, $6 ; INS 4 .DB $5, $9, $4 ; INS 5 .DB $2, $A, $6 ; INS 2 .DB $E, $2, $F ; INS E --> boucle 15 fois les 3 instructions suivantes .DB $1, $8, $A ; * INS 1 .DB $2, $9, $A ; * INS 2 .DB $0, $9, $6 ; * INS 0 .DB $5, $9, $6 ; INS 5 .DB $4, $8, $6 ; INS 4 .DB $3, $9, $6 ; INS 3 .DB $4, $8, $4 ; INS 4 .DB $F ; INS F Sound_02: ; ---> Son 2 en mode Sound Sound_05: ; ---> Son 2 en mode Sound ; (5A8) .DB $D ; INS D .DB $C ; INS C .DB $E, $4, $6 ; INS E --> boucle 6 fois les 5 instructions suivantes .DB $5, $B, $8 ; * INS 5 .DB $4, $A, $8 ; * INS 4 .DB $3, $B, $8 ; * INS 3 .DB $2, $A, $8 ; * INS 2 .DB $1, $8, $4 ; * INS 1 .DB $0, $9, $6 ; * INS 0 .DB $5, $9, $4 ; INS 5 .DB $4, $8, $2 ; INS 4 .DB $F ; INS F e5C6: .DB $8, $5, $1, $0 ; ------------------------------------------------------- ; Séquence ASM 6503 - 45 octets / 90 quartets ; ------------------------------------------------------- ; Chargée en spécifiant l'adresse $592 ; ------------------------------------------------------- ; LDX #$01 ; STX z08 ; LDX #$07 ; STX z0C ; LDX #$0B ; STX z0D ; LDA #$06 ; LDX #$91 ; JMP External_Load ; --> continue en $691 ; ; ($5CA) ; --------------------------------------------------------- .DB $E, $2, $6, $4, $C ; JMP a0E26 .DB $9, $1, $A, $2 ; LDX #$91 .DB $0, $6, $A, $9 ; LDA #$06 .DB $0, $D, $8, $6 ; STX z0D .DB $0, $B, $A, $2 ; LDX #$0B .DB $0, $C, $8, $6 ; STX z0C .DB $0, $7, $A, $2 ; LDX #$07 .DB $0, $8, $8, $6 ; STX z08 .DB $0, $1, $A, $2 ; LDX #$01 ; ------------------------------------------------------- ; Séquence ASM 6503 - 45 octets / 90 quartets ; ------------------------------------------------------- ; Chargée en spécifiant l'adresse $5B8 ; ------------------------------------------------------- ; LDX #$05 ; STX z08 ; LDX #$8B ; STX z0C ; LDX #$07 ; STX z0D ; LDA #$06 ; LDX #$91 ; JMP External_Load ; --> continue en $691 ; ; ($5EF) ; --------------------------------------------------------- .DB $0, $E, $2, $6, $4, $C ; JMP a0E26 .DB $9, $1, $A, $2 ; LDX #$91 .DB $0, $6, $A, $9 ; LDA #$06 .DB $0, $D, $8, $6 ; STX z0D .DB $0, $7, $A, $2 ; LDX #$07 .DB $0, $C, $8, $6 ; STX z0C .DB $8, $B, $A, $2 ; LDX #$8B .DB $0, $8, $8, $6 ; LDX #$8B .DB $0, $5, $A, $2 ; LDX #$05 e615: .DB $8, $8, $8 e618: .DB $7, $E, $F, $F, $8, $C, $0 Sound_03: ; ---> Son 3 en mode Sound Sound_15: ; ---> Son 15 en mode Sound ; (61F) .DB $7, $E, $F, $F, $0, $A, $0 ; INS 7 .DB $F ; INS F .DB $1 e628: .DB $A, $2, $0, $6 ; ------------------------------------------------------- ; Séquence ASM 6503 - 45 octets / 90 quartets ; ------------------------------------------------------- ; Chargée en spécifiant l'adresse $5F5 ou $605 ; ------------------------------------------------------- ; LDA #$04 ; <- appel par $605 ; STA z02 (inutilisé / son 4) ; LDA #$F6 ; STA z03 ; LDX #$03 ; <- appel par $5F5 ; STX z08 ; LDX #$AC ; STX z0C ;e0018: ; LDX #$09 ; STX z0D ; LDA #$06 ; LDX #$91 ; JMP External_Load ; --> continue en $691 ; ; ($62C) ; --------------------------------------------------------- .DB $0, $E, $2, $6, $4, $C ; JMP a0E26 .DB $9, $1, $A, $2 ; LDX #$91 .DB $0, $6, $A, $9 ; LDA #$06 .DB $0, $D, $8, $6 ; STX z0D .DB $0, $9, $A, $2 ; LDX #$09 .DB $0, $C, $8, $6 ; STX z0C .DB $A, $C, $A, $2 ; LDX #$AC .DB $0, $8, $8, $6 ; STX z08 .DB $0, $3, $A, $2 ; LDX #$03 .DB $0, $3, $8, $5 ; STA z03 .DB $F, $6, $A, $9 ; LDA #$F6 .DB $0, $2, $8, $5 ; STA z02 .DB $0, $4, $A, $9 ; LDA #$04 ; ------------------------------------------------------- ; Séquence ASM 6503 - 45 octets / 90 quartets ; ------------------------------------------------------- ; Chargée en spécifiant l'adresse $63B ; ------------------------------------------------------- ; LDA #$01 ; STA z02 ; LDA #$41 ; STA z03 ; LDA #$20 ; STA z01 ; LDA #$03 ; STA z00 ; LDA #$0A ; STA z05 ; LDA #$04 ; LDX #$F1 ; JMP External_Load ; --> continue en $4F1 ; ; ($662) ; --------------------------------------------------------- .DB $0, $E, $2, $6, $4, $C ; JMP a0E26 .DB $F, $1, $A, $2 ; LDX #$F1 .DB $0, $4, $A, $9 ; LDA #$04 .DB $0, $5, $8, $5 ; STA z05 .DB $0, $A, $A, $9 ; LDA #$0A .DB $0, $0, $8, $5 ; STA z00 .DB $0, $3, $A, $9 ; LDA #$03 .DB $0, $1, $8, $5 ; STA z01 .DB $2, $0, $A, $9 ; LDA #$20 .DB $0, $3, $8, $5 ; STA z03 .DB $4, $1, $A, $9 ; LDA #$41 .DB $0, $2, $8, $5 ; STA z02 .DB $0, $1, $A, $9 ; LDA #$01 ; ------------------------------------------------------- ; Séquence ASM 6503 - 45 octets / 90 quartets ; ------------------------------------------------------- ; Chargée en spécifiant l'adresse $671 ; ------------------------------------------------------- ; LDA #$F6 ; STA z02 ; LDA #$06 ; STA z03 ; LDA #$03 ; STA z01 ; LDA #$05 ; STA z00 ; LDA #$08 ; STA z05 ; LDA #$04 ; LDX #$F1 ; JMP External_Load ; --> continue en $4F1 ; ; ($698) ; --------------------------------------------------------- .DB $0, $E, $2, $6, $4, $C ; JMP a0E26 .DB $F, $1, $A, $2 ; LDX #$F1 .DB $0, $4, $A, $9 ; LDA #$04 .DB $0, $5, $8, $5 ; STA z05 .DB $0, $8, $A, $9 ; LDA #$08 .DB $0, $0, $8, $5 ; STA z00 .DB $0, $5, $A, $9 ; LDA #$05 .DB $0, $1, $8, $5 ; STA z01 .DB $0, $3, $A, $9 ; LDA #$03 .DB $0, $3, $8, $5 ; STA z03 .DB $0, $6, $A, $9 ; LDA #$06 .DB $0, $2, $8, $5 ; STA z02 .DB $F, $6, $A, $9 ; LDA #$F6 ; ------------------------------------------------------- ; Séquence ASM 6503 - 45 octets / 90 quartets ; ------------------------------------------------------- ; Chargée en spécifiant l'adresse $6A9 ou $691 ; ------------------------------------------------------- ; LDX #$07 ; <-- appel par $6A9 ; STX z08 ; LDX #$F8 ; STX z0C ; LDX #$0C ; STX z0D ; LDX z03 ; <-- appel par $691 ; LDA #$00 ;e0020: ; STA z01,X ; DEX ; BPL e0020 ; LDA #$04 ; LDX #$97 ; JMP External_Load ; --> continue en $497 ; ; ($6CE) ; --------------------------------------------------------- .DB $0, $E, $2, $6, $4, $C ; JMP a0E26 .DB $9, $7, $A, $2 ; LDX #$97 .DB $0, $4, $A, $9 ; LDA #$04 .DB $F, $B, $1, $0 ; BPL e0020 .DB $C, $A ; DEX .DB $0, $1, $9, $5 ; STA z01,X .DB $0, $0, $A, $9 ; LDA #$00 .DB $0, $3, $A, $6 ; LDX z03 .DB $0, $D, $8, $6 ; STX z0D .DB $0, $C, $A, $2 ; LDX #$0C .DB $0, $C, $8, $6 ; STX z0C .DB $F, $8, $A, $2 ; LDX #$F8 .DB $0, $8, $8, $6 ; STX z08 .DB $0, $7, $A, $2 ; LDX #$07 Bloc_Code_6FF: ; ------------------------------------------------------- ; Séquence ASM 6503 - 45 octets / 90 quartets ; Bloc de code 6503 en PROM et chargé en $010...$03C ; ------------------------------------------------------- ; La séquence est stockée à l'envers et sur 2 x 4 bits ; --> appel par la commande SGOL E 0 0 ; ------------------------------------------------------- ; Dans la PROM HM7643, le premier quartet est en $75B, ; l'adresse de chargement est (-90 pour le code et -2 pour ; le vecteur) = $6FF ; ------------------------------------------------------- ; LDA Memo_CMD ; Code commande reçue (sound) ; AND #$0F ; ASL ; ASL ; TAX ; LDY #$01 ;e0019: ; LDA a0463,X ; Lecture table vecteur en $463 ; AND #$0F ; STA a0000,Y ; Charge le poids faible ; DEX ; LDA a0463,X ; ASL ; ASL ; ASL ; ASL ; CLC ; ADC a0000,Y ; STA a0000,Y ; Charge le poids fort ; DEX ; DEY ; BPL e0019 ; -> traitement second octet ; LDA z00 ; LDX z01 ; JMP External_Load ; Execute le code à l'adresse $00/$01 ; ; ($706) ; --------------------------------------------------------- .DB $0, $E, $2, $6, $4, $C ; JMP $0E26 .DB $0, $1, $A, $6 ; LDX $01 .DB $0, $0, $A, $5 ; LDA $00 .DB $E, $5, $1, $0 ; BPL $0019 .DB $8, $8 ; DEY .DB $C, $A ; DEX .DB $0, $0, $0, $0, $9, $9 ; STA $0000,Y .DB $0, $0, $0, $0, $7, $9 ; ADC $0000,Y .DB $1, $8 ; CLC .DB $0, $A ; ASL .DB $0, $A ; ASL .DB $0, $A ; ASL .DB $0, $A ; ASL .DB $0, $4, $6, $3, $B, $D ; LDA $0463,X .DB $C, $A ; DEX .DB $0, $0, $0, $0, $9, $9 ; STA $0000,Y .DB $0, $F, $2, $9 ; AND #$0F .DB $0, $4, $6, $3, $B, $D ; LDA $0463,X .DB $0, $1, $A, $0 ; LDY #$01 .DB $A, $A ; TAX .DB $0, $A ; ASL .DB $0, $A ; ASL .DB $0, $F, $2, $9 ; AND #$0F .DB $0, $5, $A, $5 ; LDA $05 ; ------------------------------------------------------- ; Séquence ASM 6503 - 45 octets / 90 quartets ; ------------------------------------------------------- ; Chargée en spécifiant l'adresse $735 ; ------------------------------------------------------- ; LDA #$01 ; STA z02 ; LDA #$05 ; STA z03 ; LDA #$01 ; STA z01 ; LDA #$06 ; STA z00 ; LDA #$0D ; STA z05 ; LDA #$04 ; LDX #$F1 ; JMP External_Load ; --> continue en $4F1 ; ; ($75C) ; --------------------------------------------------------- e75C .DB $0, $E, $2, $6, $4, $C ; JMP a0E26 .DB $F, $1, $A, $2 ; LDX #$F1 .DB $0, $4, $A, $9 ; LDA #$04 .DB $0, $5, $8, $5 ; STA z05 .DB $0, $D, $A, $9 ; LDA #$0D .DB $0, $0, $8, $5 ; STA z00 .DB $0, $6, $A, $9 ; LDA #$06 .DB $0, $1, $8, $5 ; STA z01 .DB $0, $1, $A, $9 ; LDA #$01 .DB $0, $3, $8, $5 ; STA z03 .DB $0, $5, $A, $9 ; LDA #$05 .DB $0, $2, $8, $5 ; STA z02 .DB $0, $1, $A, $9 ; LDA #$01 Sound_04: ; ---> Son 4 en mode Sound ; (792) .DB $D ; INS D .DB $C ; INS C .DB $4, $A, $5 ; INS 4 .DB $3, $B, $7 ; INS 3 .DB $2, $A, $5 ; INS 2 .DB $0, $9, $7 ; INS 0 .DB $5, $9, $5 ; INS 5 .DB $4, $8, $7 ; INS 4 .DB $1, $8, $4 ; INS 1 .DB $1, $8, $5 ; INS 1 .DB $7, $0, $B ; INS 7 .DB $0, $9, $7 ; INS 0 .DB $5, $9, $7 ; INS 5 .DB $4, $8, $7 ; INS 4 .DB $3, $9, $4 ; INS 3 .DB $4, $8, $4 ; INS 4 .DB $F .DB $9 ; Table particulière en fin de la PROM ; en $7C0 e7C0: .DB $F, $F, $E, $E, $D, $D, $C, $C e7C8: .DB $B, $B, $A, $A, $9, $9, $A, $A e7D0: .DB $B, $B, $C, $C, $D, $D, $E, $E e7D8: .DB $F, $F, $E, $E, $D, $D, $C, $C e7E0: .DB $B, $B, $A, $A, $B, $B, $C, $C e7E8: .DB $D, $D, $E, $E, $F, $F, $E, $E e7F0: .DB $D, $D, $C, $C, $B, $B, $A, $A e7F8: .DB $B, $B, $8, $C, $D, $D, $E, $E .END

; ----------------------------------------------------------------------------------------------------------- ; GOTTLIEB SYSTEM 80 ; Reverse engeenering sur carte son 6503 + 6530 ; Copyright 2015 - Flipprojets - François et Thierry DAVROUX ; ----------------------------------------------------------------------------------------------------------- ; Espace adressable 6503 = 4 Ko ($000..$FFF) ; Mapping mémoire et IO : $000-$03F --> RAM - 64 octets ; $200-$20F --> Ports IO ; $400-$7FF --> PROM externe Harris (HM7643) - 1024 x 4 bits ; $C00-$FFF --> PROM interne du 6530 - 1024 octets ; ----------------------------------------------------------------------------------------------------------- ; ------------------------------------------------------------------------------------------- ; Ports IO (6530) ; ------------------------------------------------------------------------------------------- IO_6530 = $200 ; Adresse de base PORTA = IO_6530 + $00 ; R/W - Output Register A DDRA = IO_6530 + $01 ; R/W - Data Direction Register A PORTB = IO_6530 + $02 ; R/W - Output Register B DDRB = IO_6530 + $03 ; R/W - Data Direction Register B ; -------------------------------------------------------- ; Port A => Sorties vers convertisseur N/A 1408 ; Port B <= Entrées ; PB0,1,2,3 - Commandes des sons S1...S8 ; PB4 - Attract mode ; PB6 - Spare ; PB7 - Sound/tones ; ; Les switches S1 et S2 sont actifs au niveau bas (0): ; S2 - OFF => PB4 à 1 --> Attract mode désactivé ; - ON => 0 --> Attract mode actif (6 minutes) ; S1 - OFF => PB7 à 1 --> Sons en continu ; - ON => 0 --> Sons réduits (score uniquement) ; -------------------------------------------------------- ; ------------------------------------------------------------------------------------------- ; Timer (6530) ; ------------------------------------------------------------------------------------------- TIMER_6530 = $204 ; Adresse de base TIMER = TIMER_6530 + $00 ; R - Timer value TIMER_1024 = TIMER_6530 + $03 ; W - Divide by 1024 without interrupt ; ------------------------------------------------------------------------------------------- ; Variables en RAM ; ------------------------------------------------------------------------------------------- Frequence_L = $00 ; Fréquence du tone ou sound à générer sur 16 bits Frequence_H = $01 z02 = $02 z03 = $03 Div256 = $04 ; Compteur-diviseur par 256 (temporisation pour l'attract mode) Memo_CMD = $05 ; Mémorisation de la commande reçue (S1,S2,S4,S8) Data = $06 Mode_ReadAdr = $07 ; Pour lire une adresse en PROM dans Adresse1 ou Adresse2 Pointeur_SGOL = $08 ; Pointeur vers la prochaine instruction SGOL z09 = $09 Adresse_L = $0A ; Index 16 bits pour lire dans la PROM de sons Adresse_H = $0B Adresse1 = $0C ; Pour mémorisation 1ère adresse Adresse1_L = $0C ; Poids faible Adresse1_H = $0D ; Poids fort Adresse2 = $0E ; Pour mémorisation 2ème adresse Adresse2_L = $0E ; Poids faible Adresse2_H = $0F ; Poids fort RunInRAM = $0010 ; Buffer pour pouvoir executer du code 6503 dans la RAM ; (Le code sera stocké de $010 à $03C) Save_Pointeur = $10 ; Sauvegardes du pointeur (n° d'instruction) et de l'index Save_Index = $11 ; pour pouvoir relancer une commande SGOL (en cas de génération d'un ; son continu, sans limitation de durée) Flag_Infinite = $12 ; Indique si le son doit être rejoué à l'infini Sustain = $13 ; Indique la commande à maintenir pour jouer le son (ou 00) Flag_Priority = $14 ; Indique si le son est prioritaire (non interruptible) ou pas Compteur_Instr = $15 ; Compteur pour le nbr d'instruction à répeter dans un groupe REPEAT Nombre_Instr = $16 ; Nbr d'instructions à répéter dans un REPEAT (valeur à recharger) Pointeur_Repeat = $17 ; Pointeur vers la première instruction SGOL d'un groupe REPEAT Memo_Pointeur = $18 ; Mémorisation du pointeur SGOL pour boucle Adr_Ampli = $19 ; Adresse pointant sur la table des variations d'amplitude Adr_Ampli_L = $19 Adr_Ampli_H = $1A Adr_Bouclage = $001B ; Adresse de rebouclage Adr_Bouclage_L = $1B Adr_Bouclage_H = $1C z1D = $1D z1E = $1E Mode = $1F ; Mode de génération TONE ou SOUND (bit 7 - 0 = tone, 1 = sound) Force_Reset = $20 ; Flag pour forcer une réinitialisation (après l'attract mode) Nombre_Repeat = $21 ; Nombre (compteur) de répétitions (boucle SGOL, instruction REPEAT) Gen_Frequence_L = $22 ; Générateur de fréquence (compteur sur 16 bits, additionné à chaque Gen_Frequence_H = $23 ; fois de la période à générer) z24 = $24 z25 = $25 z26 = $26 z27 = $27 z28 = $28 z29 = $29 Index = $2A ; Index de la commande courante (adresse dans la table tone/sound) Duree = $2B ; Durée du son (x 20 ms) Flag_Mode_Test = $2C ; A zéro en temps normal (mis à 00 lors de l'initialisation) ; Passe à FF en mode TEST (lors de l'appui sur NMI) Vecteur_ExternH = $3B ; Utilisées uniquement avec une PROM de test pour charger du code Vecteur_ExternL = $3C ; executable en RAM. a07C0 = $07C0 ; ----------------------------------------------------------------------------------------------------------- ; Inclusion de la PROM de sons externe pour pouvoir tester (PANTHERA ou PINK PANTHER) ; ; La PROM externe est chargée sur l'espace $400-$7FF ; ----------------------------------------------------------------------------------------------------------- .ORG $400 ; .INCLUDE ".\HM7643 Sys80 Panthera.65s" .INCLUDE ".\HM7643 Sys80 Pink Panther.65s" ; *********************************************************************************************************** ; ----------------------------------------------------------------------------------------------------------- ; Début de la PROM interne ; ----------------------------------------------------------------------------------------------------------- ; *********************************************************************************************************** .ORG $C00 ; ----------------------------------------------------------------------------------------------------------- ; Table en $C00 de 32 entrées, des adresses pointant sur les séquences de variation d'amplitude. ; (partie basse uniquement, la partie haute étant fixée à $0C) ; Les séquences sont à la suite ci-dessous, à partir de l'adresse $C20. ; ----------------------------------------------------------------------------------------------------------- Vampli: .DB <VarAmpl1, <VarAmpl2, <VarAmpl4, <VarAmpl3, <VarAmpl6, <VarAmpl7, <VarAmpl7, <VarAmpl8 .DB <VarAmpl8, <VarAmpl0, <VarAmpl0, <VarAmpl5, <VarAmpl5, <VarAmpl9, <VarAmpl9, <VarAmpl9 .DB <VarAmpl9, <VarAmpl9, <VarAmpl9, <VarAmpl5, <VarAmpl5, <VarAmpl0, <VarAmpl0, <VarAmpl8 .DB <VarAmpl8, <VarAmpl7, <VarAmpl7, <VarAmpl6, <VarAmpl3, <VarAmpl4, <VarAmpl2, <VarAmpl1 ; ----------------------------------------------------------------------------------------------------------- ; Tables des séquences de variations d'amplitude ; ---------------------------------------------- ; Correspond à la pente du signal sur une évolution de 16 pas ; ----------------------------------------------------------------------------------------------------------- VarAmpl1: .DB $00, $00, $00, $01, $01, $01, $02, $02, $03, $03, $03, $04, $04, $05, $05, $05 VarAmpl2: .DB $00, $00, $01, $02, $03, $04, $05, $06, $07, $08, $09, $0A, $0B, $0C, $0D, $0E VarAmpl3: .DB $00, $02, $05, $07, $0A, $0C, $0F, $11, $14, $16, $19, $1B, $1E, $20, $23, $25 VarAmpl4: .DB $00, $01, $03, $05, $07, $08, $0A, $0C, $0E, $0F, $11, $13, $15, $16, $18, $1A VarAmpl5: .DB $00, $07, $0E, $15, $1D, $24, $2B, $33, $3A, $41, $49, $50, $57, $5F, $66, $6D VarAmpl6: .DB $00, $03, $06, $09, $0C, $10, $13, $16, $19, $1D, $20, $23, $26, $2A, $2D, $30 VarAmpl7: .DB $00, $04, $08, $0D, $11, $16, $1A, $1F, $23, $28, $2C, $30, $35, $39, $3E, $42 VarAmpl8: .DB $00, $05, $0B, $10, $16, $1C, $21, $27, $2D, $32, $38, $3E, $43, $49, $4F, $54 VarAmpl9: .DB $00, $07, $0F, $17, $1F, $27, $2F, $37, $3F, $46, $4E, $56, $5E, $66, $6E, $76 VarAmpl0: .DB $00, $06, $0D, $13, $1A, $21, $27, $2E, $35, $3B, $42, $49, $4F, $56, $5D, $63 ; ----------------------------------------------------------------------------------------------------------- ; Table des fréquences fondamentales des notes de musique ; ------------------------------------------------------- ; Commence en $CC0 et utilise 14 entrées (8 + 6) ; Les sept premières correspondent aux notes de base (do, ré, mi, fa, sol, la, si) et la huitième à la pause. ; Les six suivantes correspondent aux notes dièses (#). ; Elles sont rangées dans un ordre particulier pour pouvoir utiliser l'index + 8 en tant que dièse. ; Seul le poids faible est stocké, le poids fort sera généré automatiquement (mis à 1 pour les deux entrées ; "la" et "si" - ainsi que pour leurs diéses). ; ----------------------------------------------------------------------------------------------------------- ;-------;-----------;--------; ; Index ; Notes ; Valeur ; ;-------;-----------;--------; Notes: .DB $0B ; 0 ; A - la ; 10B ; .DB $2B ; 1 ; B - si ; 12B ; .DB $9F ; 2 ; C - do ; 9F ; .DB $B2 ; 3 ; D - ré ; B2 ; .DB $D4 ; 4 ; F - fa ; D4 ; .DB $EE ; 5 ; G - sol ; EE ; .DB $C8 ; 6 ; E - mi ; C8 ; .DB $00 ; 7 ; Pause ; 00 ; ;-------;-----------;--------; .DB $1B ; 8 ; A# - la# ; 11B ; .DB $2B ; 9 ; //////// ; 12B ; .DB $A8 ; 10 ; C# - do# ; A8 ; .DB $BD ; 11 ; D# - ré# ; BD ; .DB $E0 ; 12 ; F# - fa# ; E0 ; .DB $FC ; 13 ; G# - sol# ; FC ; ;-------;-----------;--------; ; ----------------------------------------------------------------------------------------------------------- ; $CCE - table de masques eCCE: .DB $01, $03, $07, $0F, $1F, $3F, $7F, $FF ; $CD6 - table eCD6: .DB $01, $01, $02, $02, $04, $05, $08, $0A .DB $0A, $0A, $0A ; --------------------------------------------------- ; Tables des durée de génération (multiples de 20 ms) ; $CE1 et $CE5 ; --------------------------------------------------- Table_Duree: .DB $3F ; 1260 ms .DB $2F ; 940 ms .DB $1F ; 620 ms .DB $17 ; 460 ms Table_Duree2: .DB $0F ; 300 ms .DB $0B ; 200 ms .DB $07 ; 140 ms .DB $05 ; 100 ms .DB $03 ; 60 ms .DB $02 ; 40 ms .DB $01 ; 20 ms .DB $00 ; 0 ms ; --------------------------------------------------- ; $CED - table eCED: .DB $FF, $FE, $FC, $F8, $01, $02, $04, $08 ; $CF5 - table eCF5: .DB $F0, $E0, $C0, $82, $10, $20, $40, $7E ; Zone scratch non utilisée eCFD: .DB $4B, $B4, $4B, $6B, $B4, $4B, $B4, $4B, $B4, $4B ; *********************************************************************************************************** ; ----------------------------------------------------------------------------------------------------------- ; Mode TEST (=> vecteur NMI en $D07) ; ----------------------------------------------------------------------------------------------------------- ; *********************************************************************************************************** NMIServ: LDY #$00 ; Par défaut, le son de test est un tone STY Mode ; on positionne donc le mode à TONE (bit 7 à 0) DEC Flag_Mode_Test ; Passe en mode test, met le flag à FF ; Le mode test vérifie uniquement la position des switches S1 et S2 et si elle correspond à celle ; attendue, un court son est émis LDA PORTB BMI Attract_Sound EOR #$10 BPL Attract_Sound ; *********************************************************************************************************** ; ----------------------------------------------------------------------------------------------------------- ; Début du programme (=> vecteur de RESET en $D16) ; ----------------------------------------------------------------------------------------------------------- ; *********************************************************************************************************** ; ------------------------------------------------------------------------ ; Initialisations ; ------------------------------------------------------------------------ ProgramInit: LDX #$3F ; Initialisation de la stack TXS ; (en haut des 64 octets de RAM) LDA #$00 ; RAZ des registres A et X TAX LDY #$2D ; Init du registre Y avec la valeur utilisée pour la temporisation ; de l'attract-mode. La boucle principale dure à la base 1024 x $1A ; x 256 cycles (6.815.744). On attendra donc 306.708.480 cycles avant ; de déclencher l'attract, soit environ 6 minutes @ 853 KHz. ; Initialisation de toute la mémoire à 00 ; + accès au 6530 port A (avec init au final en sorties, DDRA = $FF) RAMInit: STA $00,X CLD STX DDRA INX BNE RAMInit Check_CMD: STX Memo_CMD ; Mémorise la commande reçue (ou 00 au début) ; ------------------------------------------------------------------------ ; Boucle principale de lecture des commandes reçues ; ------------------------------------------------------------------------ Loop_CMD: LDX PORTB ; Lecture de la commande (et des switchs) BIT TIMER ; Test si le timer du 6530 est arrivé à échéance. BMI SuiteLoop ; si non, suite normale ; On teste quand le timer arrive en dessous de la valeur $80. ; En chargeant celui-ci avec la valeur $9A, on teste en réalité ; un intervale de $1A. LDA #$9A ; Si oui, on relance le timer pour une durée de 26624 cycles STA TIMER_1024 ; soit environ 28 ms. INC Div256 ; Premier diviseur par 256 BNE SuiteLoop DEY ; Second diviseur selon Y (=$2D, soit un diviseur par 11520). BNE SuiteLoop ; On passe ici tous les 11520 x 26624 soit 306.708.480 cycles. ; Donc, l'attract mode se déclenche au bout de 6 minutes environ (si horloge @ 853 KHz) TXA ; OK, on récupére le PORTB, surtout pour les switches (S1 et S2). Attract_Sound: AND #$10 ; Test si l'attract mode est activé DEC Force_Reset ; Prévoi une réinitialisation après avoir joué l'attract mode DEC Sustain ; Commande de sustain = FF DEC Save_Index TAX BEQ Start_SGOL ; Lance l'interprétation SGOL pour le son d'attract mode ; (seulement si l'attract mode est activé) SuiteLoop: LDA Force_Reset ; Test si réinitialisation forcée (après l'attract mode) BNE ProgramInit ; Pour qu'une commande reçue soit prise en compte, il faut qu'elle soit lue au moins deux fois ; de suite identiques. ; Ceci pour éviter les commandes parasites qui pourraient apparaitre sur le bus. CPX Memo_CMD ; Test si commande déjà reçue une fois BNE Check_CMD ; si non, on la mémorise et on recomence la lecture ; On s'assure qu'il y a bien une commande à traiter. ; Si les bits S1, S2, S4 et S8 sont tous à zéro, alors on reboucle au début (rien à faire) TXA ; Commande (PORTB) sauvegardée dans X AND #$0F ; Test S1...S8 BEQ Loop_CMD ; Si 0000 -> on boucle ; ------------------------------- ; Traitement de la commande reçue ; ------------------------------- Traite_CMD: STX Mode ; On positionne le mode par défaut en fonction de la commande ; TONE ou SOUND (seul le bit 7 compte) ; Calcul de l'adresse du son dans la table des sons (au début de la PROM de sons) LDY #$00 ; Offset de base pour les tones ($400) DEX BPL Adr_Tone LDY #$2D ; Offset de base pour les sounds ($42D) après les tones, soit 15 x 3 ; plus loin. A noter qu'une entrée existe pour le tone 00 en $400, ; mais qui est utilisée pour le son de test ou l'attract-mode. ; Le début de la table des sounds recouvre la fin de celle des tones ; (comme le sound 80 n'existe pas et pointe vers le tone 15), afin ; d'économiser de la place; ; On a donc : $400...$42F - table des tones 0 à 15 ; $42D...$45C - table des sound 0 à 15 Adr_Tone: TAX ; On boucle X fois pour additionner l'adresse (3 emplacements à ; chaque fois) ; X = numéro du son (mémorisé, sans distinction tone/sound) Adr_Loop: INY INY INY DEX BNE Adr_Loop ; Boucle, pour calculer l'adresse selon l'index du sound/tone STX Flag_Priority ; Par défaut, le son n'est pas prioritaire (donc interruptible) STX Nombre_Repeat ; RAZ compteur répétitions (pour instructions SGOL) ; -------------------- ; Gestion du sustain : ; -------------------- ; Soit on démarre un nouveau son depuis le début, soit on reprend celui qui est en cours et qui ; a été interrompu (on relance donc l'interprétation des instructions là où on s'était arrété). CPY Sustain BNE Start_SGOL CPY Index ; Si on est resté sur la même commande, on continue les instructions BEQ SGOL_NEXT ; --> interpreteur SGOL ; ----------------------------------------------------------------------- ; Début de l'interpréteur du langage SGOL ; ----------------------------------------------------------------------- ; La séquence commence selon l'adresse spécifiée par les registres X et Y ; X = pointeur d'instruction (commence à zéro pour la 1ère instruction) ; Y = index dans la table tone/sound (pour avoir l'adresse de base où ; commence la séquence SGOL ; ----------------------------------------------------------------------- Start_SGOL: STY Index ; Mémorise l'adresse (index) du nouveau son STX Pointeur_SGOL ; RAZ du pointeur SGOL (première instruction a l'offset 0) LDA #$04 ; Lecture de l'adresse du tone/sound dans la table de la PROM JSR PROM_ReadAdr_Son ; (La table commence en $400 - Adresse = A (H) + X (L) , l'offset est ; dans Y) ; ------------------------------ ; Interprétation du langage SGOL ; ------------------------------ SGOL_NEXT: JSR Read_SGOL ; Lecture du code instruction SGOL TXA ; A = X = code de l'instruction SGOL STY Memo_Pointeur ; -> mémorise l'adresse courante du pointeur SGOL CMP #$08 ; COMMANDE SGOL 08 --> NOP BEQ SGOL_NEXT ; Ne fait rien, lit la commande suivante LDY #$00 ; On éfface les 5 paramètres dans $00...$04 LDX #$04 ClearParams: STY $00,X DEX BPL ClearParams BCC SGOL_00_07 ; Pour les commandes 0 à 7 (samples à jouer) TAX CPX #$0B BCS SGOL_PLUS_0B ; Pour les commandes >= 0B (0B, 0C, 0D, 0E, 0F) ; =================================================================== ; COMMANDE SGOL 09 --> BREAK ; COMMANDE SGOL 0A --> STOP STY Flag_Infinite - 9,X ; 9 remet le Flag_Infinite à zéro ; A remet le Flag_Sustain à zéro BCC SGOL_NEXT ; Puis, commande suivante.. ; =================================================================== SGOL_PLUS_0B: BEQ SGOL_0B CPX #$0D BCS SGOL_PLUS_0D ; =================================================================== INC Flag_Priority - 12,X ; COMMANDE SGOL 0C --> PRIORITY ; En fait, pointe vers $14 (Flag_Priority) qui est ainsi positionné BCC SGOL_NEXT ; Puis, commande suivante.. ; =================================================================== ; =================================================================== SGOL_0B: ; COMMANDE SGOL 0B --> SUSTAIN LDA Index ; STA Sustain ; Enregistre l'index dans la commande de sustain BNE SGOL_NEXT ; Puis, commande suivante.. ; =================================================================== SGOL_PLUS_0D: BNE SGOL_PAS_0D ; Pour les commandes 0E et 0F ; =================================================================== LDA #$FF ; COMMANDE SGOL 0D --> MODE EOR Mode ; Inverse le mode, alterne entre TONE et SOUND STA Mode SGOL__NEXT: JMP SGOL_NEXT ; Puis, commande suivante.. ; =================================================================== SGOL_PAS_0D: CPX #$0E BEQ SGOL_0E ; =================================================================== SGOL_0F: ; COMMANDE SGOL 0F --> END BIT Flag_Infinite BMI Restart_SGOL ; Si en mode infini, relance la commande SGOL mémorisée LDX Flag_Mode_Test ; Mode test ? BEQ Fin_SGOL ; --> mode normal, fin de l'interprétation SGOL ; =================================================================== ; --------------------------------------------------------------------------------------------------- ; Après avoir joué le son du test, si l'entrée SPARE est mise à la masse (PB6 = 1), on charge en RAM ; une séquence de code 6503 stockée dans la PROM 7643 (au format 2 x 4 bits) en on l'exécute. ; ; Ceci semble être utilisé avec une PROM de TEST spécifique à ces cartes audio. ; --------------------------------------------------------------------------------------------------- BIT PORTB BVC Fin_SGOL ; Test entrée PB6 (spare), si pas active alors fin normale de ; l'interprétation SGOL ; Si l'entrée est active, alors cela déclenche le programme de test ; externe INX ; Adresse vecteur = $400 LDA #$04 ; (dans AX) External_Code: ; On lit le contenu du vecteur pour avoir l'adresse de base du code 6503 ; Ce vecteur est donné par les registres AX. JSR PROM_ReadAdr_Code ; La routine externe est contenu dans la PROM HARRIS 7643 sous ; forme de couples de deux quartets (formant donc un octet). ; Les données sont stockées en RAM de l'adresse $010 à $03C. ; La zone lue dans la PROM de son est inversée par rapport a la RAM, ; ce qui permet de conserver le vecteur de la commande 0 pour le son de test. ; La zone réservée pour stocker ce programme de test correspond aux 2 tables ; (sounds et tones) situées au début de la PROM. ; L'interêt de stocker en ordre inverse, c'est que le vecteur 0 (adresse $400) ; sera mis en fin du programme et on pourra donc le garder. Le programme commence ; par s'executer depuis l'adresse $010, ce qui correspond dans la PROM au contenu ; du vecteur sound 15 (qui lui n'est pas utilisé). LDX #$3F ; Réinitialisation de la stack TXS LDX #$2C ; Espace RAM réservé pour le programme = $010 à $03C Load_RAMcode: JSR PROM_ReadByte ; Lecture "byte" depuis la PROM STA $10,X DEX BPL Load_RAMcode BRK ; Execution d'un BRK (vecteur $FFFE) ; Passe le contrôle a la séquence stockée en RAM à l'adresse $010 ; --------------------------------------------------------------------------------------------------- ; Sortie de génération d'un échantillon (instructions 0 à 7), une fois sa durée écoulée. Fin_Generation: LDX Index ; Si la commande en cours est en mode SUSTAIN, on traite comme si on CPX Sustain ; avait une instruction 0F (FIN), car on boucle sur l'attente d'une BEQ SGOL_0F ; commande (et si elle est identique, on continu la séquence). CPX Save_Index BNE SGOL_NEXT ; Sinon, commande suivante.. ; Relance d'une instruction SGOL mémorisée (mode infini, on reboucle toujours sur la même) Restart_SGOL: LDX Save_Pointeur ; Charge le pointeur SGOL (n° d'instruction) mémorisé LDY Save_Index ; Charge l'index (table tone/sound) mémorisé BNE Start_SGOL ; et relance l'interprétation SGOL à partir de cette instruction ; --------------------------------------------------------------------------------------------------- Fin_SGOL: JMP SuiteLoop ; Fin de l'interprétation du SGOL, retour à la boucle principale ; =================================================================== SGOL_0E: ; COMMANDE SGOL 0E --> "REPEAT" Répétition de x commandes, n fois JSR Read_SGOL ; Lecture 1er paramètre STX Compteur_Instr ; --------------------- -> Init. du compteur d'instructions à répéter STX Nombre_Instr ; --------------------- -> et mémorise aussi la valeur à recharger JSR Read_SGOL ; Lecture 2ème paramètre STX Nombre_Repeat ; --------------------- -> Mémorisation du nombre de répétitions STY Pointeur_Repeat ; Enregistrement du pointeur vers la première instruction du groupe ; (instruction SGOL sur laquelle on boucle) BNE SGOL__NEXT ; -> Fin de la commande 0E (autre que E x 0) ; ------------------------------------------------------------------- ; Instruction E x 0 -> execution de code externe, vecteur en $6FF ; =================================================================== External_Vector: ; ------------------------------------------------------------------- ; Execution de code 6503 externe ; (stocké dans la PROM HM7643) ; Adresse du vecteur de chargement = $6XX ; ------------------------------------------------------------------- LDA #$06 DEX ; Vecteur = $6FF si lancement par commande E 0 0 (code en $702) BMI External_Load ; --------------------------------------------------------------------------------------------------- ; Instructions SGOL 0 à 7 ; Traitement de la répétition de blocs (REPEAT) ; --------------------------------------------------------------------------------------------------- SGOL_00_07: LDX Nombre_Repeat ; Si on n'est pas dans une boucle, on passe la suite BEQ NO_Repeat ; -> pas dans une boucle DEC Compteur_Instr ; Décrémente le compteur d'instruction a répéter BPL NO_Repeat ; Si pas écoulé, on continu la séquence DEC Nombre_Repeat ; Décrémente le nombre de répétitions à faire BEQ NO_Repeat ; On doit donc boucler, on recommence la séquence SGOL depuis le REPEAT LDY Pointeur_Repeat ; On remet l'adresse où le repeat commence STY Pointeur_SGOL LDY Nombre_Instr ; Recharge le compteur d'instructions à sa valeur initiale STY Compteur_Instr BNE SGOL__NEXT NO_Repeat: BIT Mode ; En mode TONE, les instructions 0 à 7 sont traitées à l'identique BPL SGOL_00_06 ; -> instructions 0 à 7 (TONE) CMP #$07 ; En mode SOUND, l'instruction 7 est traitée à part BNE SGOL_00_06 ; -> instructions 0 à 6 (SOUND) JMP SGOL_07 ; -> instruction 7 (SOUND) External_Reload: ; ------------------------------------------------------------------- ; Code jamais appelé dans le programme mais servant probablement dans ; la PROM de test. Servirai par exemple, à recharger un autre bloc de ; code à exécuter (vecteur dans $3B/$3C). ; ------------------------------------------------------------------- LDA Vecteur_ExternH LDX Vecteur_ExternL External_Load: LDY #$00 BEQ External_Code ; Donne le contrôle à une séquence externe (code 6503 encodé dans la ; PROM 7643), AX contient l'adresse du vecteur où lire ce code ; --------------------------------------------------------------------------------------------------- ; Instructions SGOL 0 à 7 ; --> Génération TONE / SOUND ; --------------------------------------------------------------------------------------------------- SGOL_00_06: ; ----------------------------------------------------------- ; On calcule la fréquence en fonction du code instruction ; et du premier paramètre ; ----------------------------------------------------------- PHA AND #$06 ; Pour les notes "la" et "si" on positionne le poids fort à 1 BNE Pas_lasi INC Frequence_H ; Fréquence de base = 0x01xx pour "la" et "si" Pas_lasi: LDA #<Boucle_TONE ; Adresse de bouclage = $EC7 LDX #>Boucle_TONE JSR Read_SGOL_Bouclage_XA ; Lecture premier paramètre TAY ; L'octave est dans Y (bits 3,2 et 1 du paramètre) PLA BCC Pas_diese ; Le dièse est spécifié par le bit 0 (récupéré dans carry) ORA #$08 ; si c'est un dièse, on lira la seconde partie de la table Pas_diese: TAX LDA Notes,X ; On récupére la fréquence fondamentale de la note depuis STA Frequence_L ; la table des notes TYA ; On traite maintenant l'octave. BEQ Octave_OK ; Pour l'octave 0, on a la fréquence fondamentale de base Octave: ; Pour les octaves supérieures, on calcule la fréquence: ASL Frequence_L ; - une octave correspond à un doublement ROL Frequence_H ; Le calcul constite donc à doubler la valeur (par simple DEY ; décalage sur 16 bits via ASL/ROL) BNE Octave ; Autant de fois qu'il y a d'octaves spécifiées. Octave_OK: JSR Read_Duree ; Lecture deuxième paramètre (durée du son) LDX eCD6,Y STX z02 DEX STX z29 LDA #$0C ; Fixe l'adresse haute de la table des variations d'amplitude STA Adr_Ampli_H BIT Mode ; Si mode TONE, c'est bon on a traité les deux paramètres BPL Boucle_TONE ; On passe donc à la génération (on saute la partie SOUND) ; ----------------------- ; --> Génération SOUND ; ----------------------- LDA #<Boucle_SOUND ; Adresse de bouclage = $E84 JSR Read_SGOL_Bouclage_A ; Lecture troisième paramètre LSR STA z24 STX z25 TAY CPX #$04 BCS eE72 LDY #$3F eE72: STY z29 LDY eCED,X STY z02 JSR Read_SGOL ; Lecture quatrième paramètre LSR STA z26 TXA AND #$07 STA z27 ; --------------------------------------------------------------------------------------------------- ; Boucle de génération SOUND ; $E84 ; --------------------------------------------------------------------------------------------------- Boucle_SOUND: INC z28 LDX z27 LDY z26 DEY DEY BMI eE95 BEQ eE92 LDX Gen_Frequence_H eE92: JSR eFEE eE95: LDA eCF5,X TAY ADC Frequence_L STA Frequence_L LDA Frequence_H DEY BMI eEA5 ADC #$00 SEC eEA5: SBC #$00 STA Frequence_H LDA z29 LDX z24 DEX DEX BEQ eEB7 BPL eEC1 LSR LSR BPL eEC4 eEB7: LDX z25 JSR eFEE LDA Table_Duree2,X BNE eEC4 eEC1: TAY LDA (Adresse1),Y eEC4: AND #$0F TAY ; --------------------------------------------------------------------------------------------------- ; Boucle de génération TONE ; $EC7 ; --------------------------------------------------------------------------------------------------- Boucle_TONE: LDA #$90 ; Joue l'échantillon pendant 16 cycles @ 833 Hz (853 Khz / 1024) STA TIMER_1024 ; soit environ 20 ms ; ----------------------------------- ; - Génération commune TONE / SOUND - ; ----------------------------------- Sample_Loop: ; [ Timing ] ; Séquence totale = 78 cycles, ; soit ~ 10936 échantillons par seconde ; La fréquence d'un son est donc au maxi de 11 Khz CLC ; [ + 2 ] ; Générateur de fréquence: on utilise un compteur LDA Frequence_L ; [ + 3 ] ; sur 16 bits que l'on additionne à chaque fois ADC Gen_Frequence_L ; [ + 3 ] ; de la valeur de la fréquence de base STA Gen_Frequence_L ; [ + 3 ] ; LDA Frequence_H ; [ + 3 ] ; ADC Gen_Frequence_H ; [ + 3 ] ; STA Gen_Frequence_H ; [ + 3 ] ; BIT TIMER ; [ + 4 ] ; Vérifie si le timer est écoulé BPL Fin_Sample ; [ + 2 ] ; si oui, fin de la génération de l'échantillon AND #$7F ; [ + 2 ] ; On utilise que le poids fort pour la variation LSR ; [ + 2 ] ; (on vire le bit 15 qui indique le sens) LSR ; [ + 2 ] ; TAX ; [ + 2 ] ; et on garde que 6 bits (soit index sur 32) ROL Flag_Mode_Test,X ; [ + 6 ] ; Séquence bidon pour temporisation ROR Flag_Mode_Test,X ; [ + 6 ] ; (Le contenu de Flag_Mode_Test n'est pas altéré). NOP ; [ + 2 ] ; Complément de temporisation LDA Vampli,X ; [ + 4 ] ; Charge l'adresse de la table de variation STA Adr_Ampli_L ; [ + 3 ] ; --> dans poids faible (le fort étant fixé à $0C) LDA #$80 ; [ + 2 ] ; Amplitude mise à la valeur moyenne BIT Gen_Frequence_H ; [ + 3 ] ; Le bit 15 détermine le sens de la variation BMI Sample_SBC ; [ + 2/4 ] ; On ajoute ou on soustrait l'amplitude lue ; Sample ADC NOP ; [ + 2 ] ; -> complément tempo pour avoir le même timing CLC ; [ + 2 ] ; entre ADC et SBC ADC (Adr_Ampli),Y ; [ + 5 ] ; STA PORTA ; [ + 4 ] ; --> sortie vers le CNA 1408 JMP Sample_Loop ; [ + 3 ] ; Boucle vers la sortie de la valeur suivante ; Pour le rebouclage (commun à tous les modes) Bouclage: JMP (Adr_Bouclage) ; Relance la séquence ; Sample ADC Sample_SBC: SEC ; [ + 2 ] ; SBC (Adr_Ampli),Y ; [ + 5 ] ; STA PORTA ; [ + 4 ] ; --> sortie vers le CNA 1408 JMP Sample_Loop ; [ + 3 ] ; Boucle vers échantillon suivant ; --------------------------------------------------------------------------------------------------- ; Points de retour en fin de lecture d'une portion SOUND/TONE ; -> Fin_Sample , après lecture pendant 20 ms du son pour les TONES et SOUND ; -> Fin_Sample2, après lecture SOUND complexe ; On vérifie si une nouvelle commande est reçue et on traite les priorités. ; On relance si la durée n'est pas écoulée, sinon on va en Fin_Generation ; --------------------------------------------------------------------------------------------------- Fin_Sample: CLC LDA z02 ADC z29 STA z29 TAX LDA a07C0,X AND #$0F TAY Fin_Sample2: LDA PORTB ; Lecture du port B pour voir si une nouvelle commande est arrivée CMP Memo_CMD ; Si différente de celle mémorisée (ou 0) BNE Nouvelle_CMD ; dans ce cas, c'est une nouvelle commande reçue Continue_Generation: DEC Duree ; On continue à générer le son tant que sa durée n'est pas écoulée BPL Bouclage ; --> rebouclage du son JMP Fin_Generation ; Fin de la génération de l'échantillon Nouvelle_CMD: STA Memo_CMD ; On mémorise la nouvelle commande LDX Flag_Priority ; Si le son est prioritaire, on ne l'interrompt pas, BNE Continue_Generation ; et on continue la génération du son TAX ; Sinon, on regarde la nouvelle commande... AND #$0F BEQ Continue_Generation ; Si c'est 0, on continue avec le son courant JMP Traite_CMD ; Sinon on passe au traitement de la nouvelle commande ; --------------------------------------------------------------------------------------------------- ; Routine de lecture du paramètre durée du son ; (commun aux instructions SGOL 0 à 7) ; Si le paramètre est une durée normale (0 à 11) on charge la valeur de la durée depuis la table, ; sinon c'est une durée infinie ; --------------------------------------------------------------------------------------------------- Read_Duree: JSR Read_SGOL ; Lecture donnée SGOL TXA TAY CMP #$0C ; Si paramètre inférieur à 12 BCC Duree_Normale ; Durée infinie, bouclage sur la même instruction SGOL LDX Memo_Pointeur ; Lecture de l'adresse mémorisée DEX ; -1 pour retomber sur le code instruction SGOL STX Save_Pointeur ; On mémorise la valeur du pointeur SGOL pour relancer LDX Index STX Save_Index ; On mémorise la valeur de l'index des tones/sounds pour relancer LDY #$00 ; Y est mis à zéro, pour charger la durée la plus longue (inutile !) ROR Flag_Infinite ; Positionne le mode infini (Carry = 1) ; Durée normale, paramètre de 0 à 12 (0 = le plus long, 11 = le plus court) Duree_Normale: LDA Table_Duree,Y ; Charge la durée du son depuis la table STA Duree RTS ; --------------------------------------------------------------------------------------------------- ; Instructions SGOL 7 ; --> Génération SOUND complexe ; --------------------------------------------------------------------------------------------------- SGOL_07: LDA #<Boucle_SOUND7 ; Adresse de bouclage = $F7A LDX #>Boucle_SOUND7 JSR Read_SGOL_Bouclage_XA ; Lecture premier paramètre BCC SGOL_07_Bit0 ; Si bit 0 du premier paramètre = 1 DEC z03 ; -> Positionne le flag a FF SGOL_07_Bit0: TAX ; Partie haute du paramètre (bits 7..1) sert d'index LDA eCCE,X STA z1D LDA Adresse1_H LDX Adresse1_L DEC Mode_ReadAdr ; -> met le bit 7 à 1 JSR PROM_ReadAdr ; Lecture deuxième paramètre (adresse 3 quartets) INY JSR Read_SGOL_Y ; Lecture cinquième paramètre BCC eF71 STY z03 eF71: TAX LDA eCCE,X STA z1E JSR Read_Duree ; Lecture sixième paramètre (durée du son) ; --------------------------------------------------------------------------------------------------- ; Boucle de génération SOUND complexe ; $F7A ; --------------------------------------------------------------------------------------------------- Boucle_SOUND7: LDY #$00 eF7C: LDA (Adresse2),Y STA PORTA AND z1E TAX eF84: DEX BPL eF84 INY TYA AND z1D TAY BNE eF7C LDA z03 BEQ eFAC BPL eF9E INC Adresse2_L BNE eFAC LDA Data ; Donnée lue dans la PROM STA Adresse2_L BNE eFAC eF9E: EOR #$01 STA z03 AND #$01 BEQ eFAA INC Adresse2_L BNE eFAC eFAA: DEC Adresse2_L eFAC: JMP Fin_Sample2 ; Fin de la génération de l'échantillon ; --------------------------------------------------------------------------------------------------- ; Routines de lecture dans la PROM son ; --------------------------------------------------------------------------------------------------- ; PROM_ReadAdr_Son : pour lire un vecteur 12 bits ; (point d'entrée des tables tone et sound au debut de la PROM) ; -> pointe vers une séquence en SGOL ; => mémorise dans Adresse1 (et écrase aussi Adresse2) ; PROM_ReadAdr_Code : pour lire un vecteur 12 bits ; -> pointe vers une séquence de code 6503 ; => mémorise dans Adresse1 (et écrase aussi Adresse2) ; PROM_ReadAdr : pour lire un vecteur 12 bits ; => mémorise dans Adresse2 ; PROM_ReadByte : pour lire un octet simple dans la PROM ; => mémorise dans Data ; --------------------------------------------------------------------------------------------------- PROM_ReadAdr_Son: ; Lecture de l'adresse des commandes du son (séquence SGOL) ; d'après les tables tone et sound au début de la PROM (en $400) LDX #$00 PROM_ReadAdr_Code: ; Lecture de l'adresse d'une séquence de code 6503 (stockée en 2 x 4 bits dans la PROM) STX Mode_ReadAdr ; -> mode lecture 00 (adresse n°1) PROM_ReadAdr: ; Lecture d'une valeur sur 12 bits (3 quartets) dans la PROM de sons ; L'adresse est dans AX (A = high, X = low) ; Selon la valeur de Mode_ReadAdr, on mémorise la valeur lue dans un registre 16 bits ; - Adresse2 (si mode_Readr est à zéro) ; - Adresse2 et Adresse1 (si mode_Readr est pas à zéro) STX Adresse_L ; Mémorise l'adresse à lire STA Adresse_H LDA (Adresse_L),Y ; Lecture 1er quartet / nettoyage AND #$0F STA Adresse2_H ; stockage valeur lue dans adresse 2 BIT Mode_ReadAdr BMI PROM_ReadByte ; si mode de lecture 0 ... STA Adresse1_H ; stockage valeur lue dans adresse 1 ; --------------------------------------------------------------- ; Point d'entrée pour lire un octet depuis la PROM (2 x quartets) ; --------------------------------------------------------------- PROM_ReadByte: INY LDA (Adresse_L),Y ; Lecture 2ème quartet / décalage ASL ASL ASL ASL STA z09 ; stockage temporaire valeur lue (4 bits haut) INY LDA (Adresse_L),Y ; Lecture 3ème quartet / nettoyage AND #$0F ORA z09 ; complément avec les 4 bits haut de la valeur STA Adresse2_L ; stockage valeur lue dans adresse 2 STA Data ; stockage en tant que donnée simple BIT Mode_ReadAdr BMI Fin_PROM_Read ; si mode de lecture 0 ... STA Adresse1_L ; stockage valeur lue dans adresse 1 Fin_PROM_Read: RTS ; --------------------------------------------------------------------------------- ; Routines de lecture d'une donnée SGOL ; --------------------------------------------------------------------------------- ; La donnée (code instruction ou paramètre sur 4 bits) est renvoyée dans X. ; Elle est lue en fonction de l'adresse de base (Adresse1) et de l'index (Pointeur_SGOL). ; ; Plusieurs fonctions sont optimisées et intégrée ici pour gagner de la place: ; - l'index (Pointeur_SGOL) est incrémenté ; - la valeur lue est également disponible sous sa forme /2 dans A (et le bit 0 dans Carry) ; ; Egalement pour gagner de la place, plusieurs points d'entrées permettent: ; - d'utiliser le registre Y comme pointeur, plutôt que Pointeur_SGOL ; - d'initialiser l'adresse de bouclage (pour la relecture de l'échantillon) ; - soit totalement (XA) ; - soit partiellement (A = poids faible) ; ; Read_SGOL_Bouclage_XA -> lecture avec init adresse de bouclage ; Read_SGOL_Bouclage_A -> lecture avec init partielle adresse de bouclage ; Read_SGOL -> lecture normale ; Read_SGOL_Y -> lecture en utilisant Y commme index ; --------------------------------------------------------------------------------- Read_SGOL_Bouclage_XA: STX Adr_Bouclage_H ; Adresse de bouclage - poids fort dans X Read_SGOL_Bouclage_A: STA Adr_Bouclage_L ; Adresse de bouclage - poids faible dans A Read_SGOL: ; Lecture d'une donnée SGOL (code ou donnée sur 4 bits) LDY Pointeur_SGOL ; Pointeur instruction/donnée SGOL Read_SGOL_Y: ; Lecture d'une donnée SGOL (code ou donnée sur 4 bits) avec index dans Y LDA (Adresse1),Y AND #$0F ; Par sécurité, on ne garde que les 4 bits faibles (PROM 7643) INY STY Pointeur_SGOL ; Pointeur++ TAX LSR RTS ; --> Routine eFEE: LDA z28 LSR BCS eFF7 INX INX INX INX eFF7: RTS ; Zone scratch non utilisée eFF8: .DB $B4, $4B ; --------------------------------------------------------------------------------- ; --------------------------------------------------------------------------------- ; Vecteurs NMI, RST et IRQ/BRK en haut de la mémoire ; --------------------------------------------------------------------------------- ; --------------------------------------------------------------------------------- .ORG $FFA NMIVector .DW NMIServ ; $D07 = NMI Service RSTVector .DW ProgramInit ; $D16 = ProgramInit BRKVector .DW RunInRAM ; $010 = BRK (pas de IRQ sur cette carte) ; --------------------------------------------------------------------------------- ; Attention - Ce programme est prévu pour un 6503 dont l'espace d'adressage est ; réduit à 12 bits. Penser à configurer les options du simulateur 6502 ; avec le mode d'adressage sur 12 bits (pour que les vecteurs NMI, RST ; fonctionnent correctement en mode DEBUG). ; --------------------------------------------------------------------------------- .ORG $FFFA .DW NMIServ ; $D07 = NMI Service .DW ProgramInit ; $D16 = ProgramInit .DW RunInRAM ; $010 = BRK .END