Hector 2HR+ Joystick Pin Outs

[yo_fr]

C'est assez simple : Les octets sont regroupés en blocs, un bloc commence par la longueur de l'entête, puis les datas.
Il existe 2 famille de bloc :
Le bloc d'entête (TOL) : C'est le 1er bloc rencontré et il y en a plusieurs sur un chargement de logiciel du commerce. On y trouve donc en 1er octet la longueur puis les paramètres et enfin le code du bloc.
Suite à ce bloc d'entête il peut, dans certain cas, être suivi d'un bloc de données, par exemple dans le cas d'un bloc de remplissage ou d'un bloc de données.


Le soft Monitrix permet de gerer les blocs unitairement.

Voici les différents codes de bloc :

Code : Tout sélectionner

   ' Les codes de TOL sont les suivants (doc monitrix) :
   ' code FF => bloc de données en page PROG,
   '              Programmation : FF, destination, longueur, source
   '                    exemple : FF, 7000, 1000, 6000   Prendre 1000H octets en 6000 et les replacer en 7000.
   '                   ce qui donnera sur la cassette : 
   '                                 05 00 70 00 10 FF suivi des data 00 nn nn nn ... nn 00 nn nn nn .. nn 
   ' code FB => bloc de données en page VIDEO (idem FF mais en page vidéo)
   ' Bloc FD => Fin de fichier !
   '              PRogrammation : FD,départ, pile, 0
   '                    exemple : FD, 7000, 9000, 0  Fin avec saut (7000) et pile (9000)
   '                    
   ' code FE = remplissage d'une zone avec une constante :
   '             Programmation :  FE, adresse, longueur,valeur 
   '                    exemple : FE,6000,1000,0055 : Remplir la zone 6000 - 6FFF avec la constante 55
   '
   ' Sur la cassette c'est idem, on retrouve les codes de TOL :
   ' En fait les 5 premiers octets c'est la longueur des data de la TOL, ainsi que l'adresse :
   ' longueur BLOC = Data(Pointeur_octet + 0) 'usuellement une TOL fait 5 octets
   '          Adr0 = Data(Pointeur_octet + 1)
   '          Adr1 = Data(Pointeur_octet + 2)
   '          Lon0 = Data(Pointeur_octet + 3)
   '          Lon1 = Data(Pointeur_octet + 4)
   '      code_TOL = Data(Pointeur_octet + 5)

   ' Suite à la lecture des octets 1+5 octets décrivant la TOL, viennent les bloc de données :
   '         Taille data = Data(Pointeur_octet + 0) => donne le nombre de données devant arriver : 
   '              data 1 = Data(Pointeur_octet + 1)
   '              data 2 = Data(Pointeur_octet + 2)...
   '              data n = Data(Pointeur_octet + n)
   '     
   'Si la taille du bloc de données = 1 => 1 octet à lire, 2 => 2 octets à lire ... 
   ' 255 => 255 octets à lire et 0 ... => 256 octets à lire ... oui oui, on est bien sur un système 8 bits !

ce qui donne, par exemple, en début de cassette FORMULE1 :
05 00 40 A0 09 FE 01 00 05 DB 5F 02 00 FF…
=> 3 blocs :
Le premier avec L= 05, code FE (à la fin) : fait un remplissage de l’écran (4000 @ écran BR, 9A0 : taille écran BR) avec l'octet du bloc de données suivant :
Le 2eme Bloc L=01 paramètre = 00 (1 octet de donnée :0) est l'octet à mettre dans l'écran réclamé par le bloc FE...

Le troisième bloc : avec le code de données (FF à la fin) sur 5 octets : à l'adresse 5FDB longueur de 0002 octets qui sera suivi d'un bloc de data d'une longueur de 2 !... Si la longueur était plus grande (supérieur à 256 octets) il y aura alors plusieurs bloc de données de 256 puis le dernier avec le modulo nécessaire..

c'est donc entre le 2eme et le 3eme bloc qu'il faut ajouter des synchros de façon à ce qu'hector puisse faire le remplissage de la mémoire écran sur une longueur de 9A0 octets. Il me semble (de mémoire) que j'ajoutais 400 cycles de synchro.


D'ailleurs, j'avais amorcé la réflexion ici :
http://forum.system-cfg.com/viewtopic.p ... loc#p26704


mais ici l'explication est correcte, sans aucun doute (de ma part).

[Daniel]

Merci beaucoup pour ces explications.

Dans formule 1, après le bloc de longueur 5 terminé par $FE, le bloc 1 venant ensuite est effectivement suivi de beaucoup plus de signaux de synchronisation. J'en ai compté 150. Je ne sais pas si c'est suffisant dans tous les cas ?

Le programme dchectork7 est modifié. Le nombre de signaux de synchronisation est toujours de 4 après chaque bloc, sauf les blocs de longueur 1 suivant un bloc de longueur 5 et de type $FE. Pour ces blocs de longueur 1 il y a 150 signaux de synchronisation. J'ai gardé les 6000 signaux de synchronisation en début de cassette.

Vous trouverez dchector v2014.01.01 à la section Téléchargement du site http://dchector.free.fr

[yo_fr]

Pour les synchro en début le minimum de synchro que doit voir Hector c'est 0x0300h cycles (768 décimal). Pour créer une cassette réelle, ce que tu as mis permet d'enregistrer sereinement.
Par contre entre bloc ça ne marche pas sous MESS (je ne peux essayer sur ma machine aujourd'hui). Sur la K7 B3X, il se plante ainsi qu'avec la k7 formule 1.
Pour les inter-bloc j'utilise 140 synchro, mais j'ai essayé avec 150 et ça marche aussi. Je ne vois pas, de base, la différence. Il faudrait que j'étudie le wav produit par ton outil.

Pour les périodes moi j'utilise :
UN :1.15ms (0.9)
ZERO :0.55ms (0.6)
SYNCHRO : 1.75ms (1.5)

les chiffres indiqués entre parenthèses sont les paramètres théoriques qui ne sont pas terrible et ceux indiqués hors parenthèses sont ceux qui fonctionnent nickel.
Si tu veux je t'envoi mon code VB et un WAV transformé (ainsi que l'exe en VBmanagé).
JJ
[EDIT] D'ailleurs c'est assez bizarre car sur les 2 soft, les pages de présentations passent bien, ce qui indique que les bloc FE passent correctement... Est-tu sur d'écrire correctement le dernier bloc (bloc de fin : FD) sans synchro derrière ? Essaye peut-être de mettre 8 cycles de synchro entre bloc...

[Daniel]

Merci pour l'envoi de ton programme !
Je vois que tes créneaux sont réguliers (demi-période positive égale à la demi-période négative). Par contre, dans le fichier .wav original de Formule 1, les créneaux négatifs sont beaucoup plus courts. Ce fichier a peut-être été enregistré avec un magnétophone déréglé ? Et comme j'ai mesuré les durées sur cet exemple précis, j'ai peut-être de mauvais chiffres.

J'ai relevé le nombre d'échantillons entre deux changements de signe :
Synchro : 60 échantillons positifs + 15 négatifs (1.36 + 0.34 = 1.70 ms)
Bit 0 : 15 échantillons positifs + 15 négatifs (0.34 + 0.34 = 0.68 ms)
Bit 1 : 30 échantillons positifs + 15 négatifs (0.68 + 0.34 = 1.02 ms)
J'ai bien mis 4 synchros après chaque bloc (y compris le dernier), avec une exception pour le 2ème bloc (longueur 1) : 150 synchros.
Le fichier .wav généré ressemble beaucoup à l'original, mais un petit détail m'échappe peut-être.

Peu importe, si ton programme fonctionne bien c'est l'essentiel. Le mien sera vite oublié. Comme je n'ai pas d'Hector je n'en ai pas l'utilité, et je ne perdrai pas de temps sur le sujet. C'était juste pour essayer