[THOMSON] Mémoire de TO7/70

[LeGrapyl]

J'ai cette extension mémoire EM97-64... je ne sais pas si elle fonctionne et je ne dispose pas de la cartouche Basic 128.
J'aimerai donc trouver un moyen de la tester. J'imagine que ça pourrait planter si ça ne fonctionnait pas, ce qui n'est pas le cas...

Dans le chapitre VII pages 205 et 206 du manuel de ref - basic, (voir sur le site DCMOTO) on trouve des programmes pour "lister" la mémoire. Or,dans l'annexe F p.220, il est expliqué que la machine commute vers les blocs de 16k au delà de la limite des 32k utilisables simultanément.
1- Alors pouvez vous m'aider à écrire un programme qui utilise à la fois le programme de test et le programme de commutation de bloc mémoire pour tester l'extension 64k ?
2- Je veux bien en profiter pour essayer de comprendre les plages d'adresses exprimées en héxadécimal (0000 -3FFF cartouche mémo7, 4000-5FFF mémoire écran...). Ca veut dire quoi ? qu'il y a un groupe de 8 bit à l'adresse 0000, un autre à l'adresse 0001 etc ?

[__sam__]

2- Je veux bien en profiter pour essayer de comprendre les plages d'adresses exprimées en héxadécimal (0000 -3FFF cartouche mémo7, 4000-5FFF mémoire écran...). Ca veut dire quoi ? qu'il y a un groupe de 8 bit à l'adresse 0000, un autre à l'adresse 0001 etc ?

Non rien à voir avec les bits. Ce sont les plages d'adresse mémoire où l'on trouve des elements spécifique. Si tu es familier avec l'hexa tu auras remarqué que 16Ko = $4000 = 0x4000 (= 4000 dans le manuel technique qui est écrit implicitement en hexa). La zone $0000 à $3FFF fait ($3FFF - $0000) +1 = $4000, soit exactement 16Ko. Cela correspond à la zone cartouche. Si $4000 vaut 16Ko, ca signifie que $2000 (la moitié) vaut 8Ko, et c'est précisément la zone dispo pour la ram video entre $4000 et $5FFF. Or la ram video TO7 fait 16ko, on en voit donc que la moitié. C'est là que la notion de banque intervient. En modifiant un bit dans un registre on peut faire apparaitre entre $4000 et $5FFF la banque mémoire video de forme ou de couleur. Cette histoire de banque est aussi utilisée pour adresser l'ensemble de l'extension 64Ko dans la zone $A000 à $DFFF qui ne fait que 16Ko. En fait la zone de 64Ko est tronçonnée en 4 banques de 16Ko que l'on peut faire apparaitre entre $A000 et $DFFF en changeant quelques bits dans les registres hardware du système.

Pour résumer le découpage des 64Ko adressables sur TO est comme suit:

• $0000 à $3FFF : 16ko correspondant à la cartouche mise dans le connecteur. C'est comutable entre les différente banque ROM de la cartouche. Cette zone est en lecture seule sur TO7 TO7/70 et TO9. Sur TO8 et TO9+ on peut aussi mapper une zone de ram à cette adresse auquel cas on peut y écrire aussi.
• $4000 à $5FFF : 8ko commutable correpondant soit à la ram video forme, soit à la ram video de fond (couleur)
• $6000 à $9FFF : 16Ko de ram non commutable.
• $A000 à $DFFF : 16 ko de ram commutable, on y voit l'une des banque de l'extension mémoire interne ou externe.
• $E000 à $FFFF : 8ko de rom moniteur (le BIOS de la machine) et de registres hardware. Non commutable.

[irios]

Pour faire plus simple :
Un microprocesseur 8 bits a un bus d'adresses de 16 bits ce qui mathématiquement parlant il peut adresser 2^16 adresses soit 65536 adresses. Pour les THOMSON, les concepteurs ont décrétés que dans cette plage certaines zones sont découpées pour les accès mémoires vives (DRAM,SRAM, ...), les accès mémoires mortes (uniquement en lecture, EPROM, EEPROM, PROM, ...) et les accès aux entrés/sorties (Vidéo, K7, clavier, stylo, parallèle, série, ...) au travers de composants particuliers tels que PIA 6821 pour les accès parallèles, ACIA 6851 pour les accès séries, PIT 6840 pour les compteurs/décompteurs, VDU 6847 pour la vidéo, ...

Regardes là pour savoir comment faire un plan d'adressage sur un système à microprocesseur : http://bacstielectronique.free.fr/fichi ... _MICRO.pdf

Amuses toi bien !!!

[LeGrapyl]

@Sam : Je ne suis bien évidemment pas très au fait de la manipulation du systeme hexa...dis toi que j'ai 12 ans...
tu calcules comment ton 16k ? j'obtiens bien un 16656 en faisant 16*16^0+16*16^1+16*16^2+3*16^3 je suis sur la bonne voie ?
En plus, le programme en assembleur pour commuter les blocs t'imagines bien qu'il y a un gros gros travail pédagogique a faire !!

@Irios:

Pour faire plus simple :

Quel déconneur celui là ! Passer un bacSTi à 12 ans en plus c'est 2^16 qui fait 65536

[fneck]

2- Je veux bien en profiter pour essayer de comprendre les plages d'adresses exprimées en héxadécimal (0000 -3FFF cartouche mémo7, 4000-5FFF mémoire écran...). Ca veut dire quoi ? qu'il y a un groupe de 8 bit à l'adresse 0000, un autre à l'adresse 0001 etc ?

Oui, il y a bien 8 bits (un octet) à l'adresse 0000, 0001,0002... et ainsi de suite jusqu'à 3FFF. Et même jusqu'à la fin de la mémoire adressable par le processeur, soit FFFF ou 64Ko.

[__sam__]

@Sam : Je ne suis bien évidemment pas très au fait de la manipulation du systeme hexa...dis toi que j'ai 12 ans...
tu calcules comment ton 16k ? j'obtiens bien un 16656 en faisant 16*16^0+16*16^1+16*16^2+3*16^3 je suis sur la bonne voie ?

presque. Mais en base 16 les chiffres vont de 0 à 15, donc ton premier 16*16^0 n'est pas bon.

L'hexa c'est comme la base 10, mais on compte sur 16. 0 à 9 valent leur valeur propre. A vaut 10, B=11, C=12, D=13, E=14, F=15.
16Ko c'est 16 * 1024 = 16384 octets. Maintenant si tu prends $4000 (le $ en début veut dire qu'on compte en hexa), il vaut 4*16^3 + 0*16^2 + 0*16^1 + 0*16^0 = 16384, 16Ko! Si tu prends $3FFF tu obtiens 3*16^3 + 15*16^2 + 15*16^1 + 15*16^0 = 16383 = 16384 - 1. Bref $3FFF = $4000 - $0001, ce qui est logique car si tu fais 1+$3FFF, tu poses:

Code : Tout sélectionner

$ 3 F F F
$ 0 0 0 1 
=========
$ . . . (16)

Or 16 n'est pas représentable avec un seul chiffre. Il vaut $10 en hexa. On pose alors 1 sur la colonne des seizaines et on fait l'addition:

Code : Tout sélectionner

R     1 (retenue)
$ 3 F F F
$ 0 0 0 1
=========
$ . . . 0

On retombe alors sur 1 + $F + 0 = 16 = $10, donc on repose 1 sur la colonne des 256-aines:

Code : Tout sélectionner

R   1 1
$ 3 F F F
$ 0 0 0 1
=========
$ . . 0 0

A nouveau 1 + $F + 0 = $10, on ajoute donc 1 sur la dernière colonne:

Code : Tout sélectionner

R 1 1 1 
$ 3 F F F
$ 0 0 0 1
=========
$ . 0 0 0

Il vient donc 1 + $3 + 0 = $4 et donc le résultat $3FFF+$0001=$4000

Code : Tout sélectionner

R 1 1 1
$ 3 F F F
$ 0 0 0 1
=========
$ 4 0 0 0

En plus, le programme en assembleur pour commuter les blocs t'imagines bien qu'il y a un gros gros travail pédagogique a faire !!

Il faut progresser dans l'ordre. Si tu veux faire ca en te marrant, je te conseille les cours d'asm d'hebdogiciel que j'ai regrouppé là: http://www.logicielsmoto.com/phpBB/viewtopic.php?t=419, et en particulier les numéros 59 et 64 sur "les bases" (jeu de mot! Maitre Capello met 1 franc dans le nourrain).

[LeGrapyl]

Je pensais justement aux cours d'hebdo et je me disais qu'il me fallait faire du tri à partir de la source que tu as utilisé...mais si en plus tu as tout regroupé c'est formidable "Et de bon aloi !"...
Merci Sam !
PS : 1 franc dans le nourrain, ca fait environ $F centimes d'euros en Héxa ?

[__sam__]

Je te conseille d'imprimer les page d'hebdo, car il est plus facile de lire du papier que l'écran d'ordinateur au format journal je trouve.

Ah oui j'ai oublié de dire que l'hébdo donne les adresses décimal ce qui est je crois anti-pédagogique car on ne voit pas la logique du codage de l'adresse permettant de savoir si l'on parle d'une adresse dans le moniteur ($Exxx ou $Fxxx) d'une adresse en ram video ($4xxx ou $5xxx), en page0 du moniteur ($60xx), en ram non commutable ($6yxx à $9xxxx) ou commutable ($Axxx à $Dxxx). Quand ils donnent de l'hexa ils n'utilisent pas le préfixe "0x" propre au langage C ou "$" propre à l'assembleur, mais "&H" qui est propre au basic.

Heu sinon, oui 1franc=$F centime d'euros, soit $0.266 €. En effet on peut utiliser des nombres à virgule aussi bien en hexa qu'en décimal, mais à chaque place à droite de la virgule on est dans les puissances négatives de 16: 0.15 = 2/16 + 6/16^2 + 6/16^3 + 6/16^4. Pour trouver les digits, c'est assez facile, tu multiplie par 16 la partie fractionnaire du nombre. La partie entière du résultat donne le chiffre après la virgule et tu ré-itère avec la nouvelle partie fractionnaire.

Mise en application: 0.15 * 16 = 2.4 on en déduit que le 1er chiffre après la virgule est un deux. Pour avoir le chiffre suivant on prend la nouvelle partie fractionnaire et on multiplie par 16: 0.4 * 16 = 6.4. Le chiffre suivant est donc un 6. Pour le chiffre qui suit, on prend la nouvelle partie fractionnaire 0.4 et on multiplie par 16 ce qui donne 6.4, donc le nouveau chiffre est aussi un 6.. on constate alors que tous les chiffres à venir sont identiques à 6 (parce que 0.4 * 16 = 6 + 0.4). Donc 0.15 (décimal) = 0.26666.... les 6 se répètent à l'infini en hexa un peu de la même façon qu'un tiers = 0.3333333 en décimal. [Si tu n'as rien compris à ce paragraphe, c'est pas grave car en ASM on utilise pour ainsi dire aucun nombre à virgule. Disons que c'est de la culture générale facile car je trouve que la conversion des nombres plus petit que 1 dans une base arbitraire bien plus facile que la conversion de la partie entière].

Au fait, sur la photo c'est pas 1 franc que met le Maitre, mais 100francs (l'inflation sans doute...). Et 100 francs ca fait $64 ... (francs et pas dollars contrairement à la notation ).

[Daniel]

Pour revenir à la question initiale :

Les banques de ram du TO7/70 sont sélectionnées par les 5 bits de poids fort du port B du PIA système (6821). Ce port est à l'adresse $E7C9. Pour accéder à la mémoire commutable, il faut donc sélectionner chacune des banques en écrivant son numéro dans les 5 bits de poids fort de $E7C9.

Pour tester si une banque est bonne, il faut faire une boucle sur les 16 K entre $A000 et $DFFF, lire l'octet, écrire une valeur différente, relire pour vérifier la valeur écrite, puis rétablir la valeur initiale.

Si tu ne maîtrises pas le langage machine tu peux écrire le programme de test en Basic, mais il faudra de la patience car l'exécution sera très longue. Il faudra aussi commencer le programme par le CLEAR qui va bien pour qu'il reste en mémoire non commutable, sinon il risque de s'auto-détruire.

[irios]

Corrigé, j'ai frappé plus vite que mon ombre !!!

[LeGrapyl]

PREAMBULE : J'ai un conseil à tous les ignares comme moi qui voudrait comprendre le systeme hexadécimal : il suffit d'expliquer à votre fille de 12ans comment fonctionne le système décimal avec des 10 et leur puissance... 10, c'est 10^1, 100, c'est 10^2 etc... ça c'est facile ; du coup en hexa faut multiplier X(la valeur en héxa de 0 à 15) par 16 à la puissance correspondant à son rang en partant de la droite...
Pourquoi je ne vous ai pas eu comme prof de math au collège et au lycée ? hein pourquoiiiiiiiii

- Hexa, la base est intégrée (enfin je crois...)
-@Irios : Le bus d'adresses... je comprends le système mais le lien, je le laisse de côté pour le moment : pas assez à l'aise avec l'interprétation des schémas...Pour le calcul, j'ai fait l'erreur inverse (les chiffres vont de 0 à 15,pas 16...) donc je comprends !
-Le cours d'assembleur : je vais effectivement imprimer et m'y mettre avec la soluce d'Hebdogiciel.

Reste :Le programme en basic.
-RE-PREAMBULE : Est ce que je peux faire des tests sur DCMOTO sans risquer d'endommager le matériel ?
-Pour vérifier le contenu de la mémoire, ce sont les instruction Peek (lire?) et Poke(ecrire?). Il faut juste lire, ecrire et vérifier le contenu pour la plage d'adresse définie ($A000 à $DFFF soit 40960 à 57343)...Ca, j'ai bien compris ?

[...] sélectionnées par les 5 bits de poids fort du port B du PIA système (6821)[...]l'adresse $E7C9. Pour accéder à la mémoire commutable, il faut donc sélectionner chacune des banques en écrivant son numéro dans les 5 bits de poids fort de $E7C9.

heuuuuuuuuu ? Comment je fais pour "commuter" d'un block 16k aux autres ? Je crois que c'est ce que tu essayes de m'expliquer mais ça m'a déclenché une "IO Error",données illisibles

[irios]

Si tu veux des cours, tu peux passer à la maison !!!

[LeGrapyl]

Des cours contre de la main d'oeuvre en maçonnerie ? Pourquoi pas !

[Daniel]

heuuuuuuuuu ? Comment je fais pour "commuter" d'un block 16k aux autres ? Je crois que c'est ce que tu essayes de m'expliquer mais ça m'a déclenché une "IO Error",données illisibles

Quand tu écris les 5 bits de poids fort dans $E7C9, il ne faut pas modifier les 3 bits de poids faible. Donc il faut commencer par lire l'octet (par un PEEK(&HE7C9)), extraire les 3 bits de poids faible (par AND 7) puis ajouter les 5 bits de poids fort (par OR). Ensuite tu écris le tout par un POKE &HE7C9...

Tu peux tester sur dcmoto ou sur la vraie machine, dans les deux cas il n'y a aucun risque de détruire le matériel, sauf si tu t'énerves et le jettes par la fenêtre. Comme dit précédemment l'exécution du programme Basic sera longue. Si tu sais négocier avec Sam, je suis sûr qu'il pourra faire l'équivalent en assembleur en moins de 10 lignes, et le programme sera au moins 500 fois plus rapide

[__sam__]

Daniel, il me semble qu'écrire les bits de poids fort ne marche pas sur TO9 (et TO7). Ce qui compte c'est le sens de la direction des bits du port B comme l'indique le manuel technique du TO8 page 44 et 45.

En basic pour commuter sur le code bank CODE%, il faudrait faire

Code : Tout sélectionner

10 REM CODE% = &h0F ' BANQUE 0
20 REM CODE% = &h17 ' BANQUE 1
30 REM CODE% = &hE7 ' BANQUE 2
40 CODE% = &h67 ' BANQUE 3
50 REM CODE% = &hA7 ' BANQUE 4
60 REM CODE% = &h25 ' BANQUE 5
100 ' PASSAGE DU PIA EN MODE DIRECTION
110 POKE &hE7CB, PEEK(&hE7CB) AND &hFB
120 ' MODIFICATION DES DIRECTION D'ECRITURE DANS LE DDRB DU PIA EN E7C9
130 POKE &hE7C9, CODE% ' voir les valeurs du code ci-dessus
140 ' PASSAGE DU PIA EN MODE DONNEES (RETOUR CONFIG DEPART)
150 POKE &hE7CB, PEEK(&hE7CB) OR &h04

D'après la traduction du code ASM donné en page 44 du manuel technique.