Article Rétro (Amstrad)

On m'a demandé sur Oniro de parler de ma passion du vrais rétro. Mais je vois que finalement ça fais un flop xd Je ne pense plus publier la ba mais j'aime un peu écrire des "articles" cela me permet aussi de coucher par écrit mes connaissances et m'aide à apprendre à connaitre une machine en particulier. L'amstrad 6128. Voici donc un article que j'ai écris sur les processeurs. Il y a un peu d'abus de langage, et de simplification...
Certain doivent savoir tout ça et bien plus que moi mais ça peut être intéressant pour d'autre.

A vous de voir si vous voulez que je continue d'écrire d'autre articles/connaissance sur cette machine ou pas. A vous de voir.

Le Processeur!
Coucou, voici un petit pitch sur les procos !!!
Alors c'est quoi c'est un processeur ? C'est le coeur d'une machine électronique. (Console,Ordinateur…) C'est lui qui va travailler, et organiser tous le bousin. A l'heure actuel au moment ou j'écris ses lignes, le proco est en mode, 'bon je récupère la valeur de la touche que monos est entrain d'utiliser, je la stocke ici, après cette valeur envoyer que l’envoie ici….
Puis il ne fait pas que ça, un bon vrais petit esclave qui bosse bien, mieux que les chinois à nonor sur Aëdemphia…

Bon sérieusement, oui le proco est un des organes les plus important d'un pc ou d'une console de jeu.(qui sont maintenant des pc avec moins de possibilité mais passons)

Il y a quoi dans un processeur ? Comment il fonctionne ? Pour répondre un peu a cette question je vais parler d'un vieux processeur dit 8bits, Le Z80 ! Et beaucoup d'entre vous avez eu affaire à ce processeur ! Il équipe des vieux micros comme l'amstrad, et le standard MSX, au niveau console je peux en cité 4 de mémoire, La Master Système de chez Séga, La Mégadrive de Chez séga. (C'était é la pour la rétrocompatibilité et pour manipuler le chipet musical), la Game Gear de chez Séga et Nintendo utilise une version lite pour sa Game Boy !

Bon un processeur possède de la mémoire internet. Limité  sur un système 8 bits mais très rapide. Nous les appelons les registres.
Le Z80 possède  donc des registres dit 8 Bits nommé arbitrairement.
A,B,C,D,E,F,H,L
Chacune de ses 8 huits registres peuvent mémoriser un valeur entre 0 et 255. (1 Octet donc)
Le Registre A est ce que nous appelons l'accumulateur. Il est reliés de telle sorte que sur certaine instruction, on passe par lui pour gagner de la rapidité, et de la mémoire. (Souvent tout ce qui touche au calcule)
Le Registre F est le registre des Drapeaux. (Flags) il sert à mémoriser des tas de choses, comme une retenue, ou si A est égale à 0…

Sur le Z80 on peux combiner par paire les registres. Le registre H et L sont souvent regroupés pour travailler avec des Adresses mémoires.  (Ah j'ai perdu du monde la, je reviendrais dessus)

Le Z80 possède aussi des registres dit 16 bits. Qui permet donc de mémoriser une valeur en 0 et 65535

Nous avons dans ce domaine le registre PC qui lui permet donc de retenir la prochaine adresse mémoire à lire. (Le registre PC s’agrémente de 1 à chaque fois qu'il est sollicité) , le registre SP qui est le pointeur de pile. (La j'ai encore perdu du monde,  En gros c'est une valeur qui est l'adresse mémoire qui contient elle même une adresse mémoire bon oublions) et deux autres registre 16 bits nommé IX et IY  qui est utilisé dans des instructions du proco (instruction ? Oué je vais en parler)

Voici en gros ce que possède le proco Z80 en mémoire.

Un deuxième processeur 8 bits fut souvent utilisé par le passé.
Le Motoral 6502. Proco du C64, de la nes (avec modification)
Ceci dit je ne le connais pas vraiment.

Je parlais des adresses mémoire. C'est quoi une adresse mémoire ? C'est simple c'est une valeur qui permet d'identifier une case mémoire de votre ordinateur et chaque case mémoire c'est un octet. (8 bits, une valeur entre 0 et 255)
Donc un pc avec 4Go, ba c'est  4 000 000 000 de cases environs avec chacun un numéros.
Donc votre proco va aller déposer des valeurs , ou l'inverse les lires. C'est ce que nous appelons l'adressage de mémoire.

Petit information on dit souvent qu'un proco 32 bits ne peux pas utiliser plus de 4Go pourquoi ?
Voici une supposition « Windows 32 » ne peux manipuler au maximum des valeurs comme son nom l'indique de 32 bits. (On peux foutre Windows 32 sur un proco 64 bits donc la c'est le logiciel qui bride) la valeur maximum de 32 bits est 4 294 967 295
Voilà pourquoi cette limitation.  Encore un petit truc, c'est la limite que windows 32 peux travailler en « même  temps ».  Il existe des bidouilles qui permet de sauter cette limite en switchant une partie de la mémoire par une autre !!! (La mémoire Paginé)

Maintenant passons sur 8bits. Qu'elle est la mémoire maximum disponible sur un proco 8 bits ? Enfin nous allons parlé du Z80.
256 octet ?
Bien essayé mais non.
Nous avons le registre PC qui permet de mémoriser une adresse mémoire. C'est un registre 16 bits.
Et 16 bits c'est 65535
Donc la mémoire disponibles maximum est de 65 355 octet. Sois 64k dans le langage que nous utilisons le plus souvent.

Ceci dit comme pour windows on peux tricher et échanger des morceaux de la ram par d'autre. Ce que l'amstrad CPC 6128 fait avec ses 128ko de mémoire vive.

Bon plus haut j'ai parlé d'instruction !
Le processeur c'est con, il ne connais que deux chiffre. 0 ou 1. Ouvert ou Fermé.  On ou OFF. Courant ou pas de Courant ! C'est le système Binaire. Et sur Rpg Maker vous l'utilisez souvent avec les interrupteurs par exemple.  Votre ordinateur, c'est continuellement.

Alors concrètement comment ça fonctionne ?
C'est simple, si je vous dit : Et toi mec tu vas aller de l'autre coté de la falaise, une fois en place, si je lève mon bras, tu lances une pierre. Sinon tu ne fais rien. L'exemple est con je veux bien l'avoué.
La on a donc deux situations, soit il ne fait rien, soit j'ordonne à mon ami de jeter une pierre.
Ceci dit seulement deux actions c'est mince. Je vais chercher un ami qui a coté de moi va aussi lever ou pas son bras avec moi. On passe donc à 4 ordres possible à donner à mon copain de l'autre coté de la falaise. Et si je veux continuer à ajouter à mon catalogue plus d'ordre, j'ajoute un 4em gus à coté moi, voir plus. Voyons nous sommes 8. Ce qui nous donnes 256 possibilités d'ordre codé sur un bras non levé (0) ou un bras levé (1)

Le proco c'est la même chose. Enfin presque car lui c'est pas des Bras que nous levons xd mais on lui injecte des 0 et des 1. Chaque groupes de 8 chiffres dans une case mémoire (1 octet donc)  est potentiellement une instruction.  (Ou un départ d'instruction car sur certain ordre, il faut plusieurs octet ce qui augmente le nombre d'instruction potentiellement connus du proco)

Le proco va lire le contenue du registre PC qui est une adresse mémoire, va aller chercher la valeur contenue à cette adresse, va incrémenter de 1 le PC, va déchiffrer l'ordre  et ensuite l’exécuté !

Exemple dans PC il y a l'adresse 3000.
Dans 3000, la valeur est 4. Il décrypte et pour le Z80, il sait qu'il doit ajouter 1 à la valeur contenue dans le registre A. (Véridique)

Par contre sur un autre processeur c'est peut être l'inverse. Il faut retirer 1 à la valeur contenue de son accumulateur  ou je ne sais pas quoi.

Ceci est le langage Machine ! Le pure langage machine ou chaque octet est une instruction que le processeur peut comprendre… Et chaque processeur à son propre langage ou presque car il existe des familles qui partage des instructions pour être compatible. C'est le cas des « X86 » ou la base est le même langage mais suivant les procos (Intel,AMD, et leurs différente Famille I7, Pentium …)
possèdé des instruction en plus ou différent.

Oué mais programmer en 0 et en 1 c'est pas top heins ! Risque d'erreur, et tout ça.
C'est vrais. Et c'est pour ça que l'homme s'est simplifier la vie et qu'il  a créer ce que nous appelons le langage « assembleur » .

Ajouter  1 à la valeur contenue dans le registre A ! Dans un assembleur Z80 on pourra écrire
Inc A

On lance la compilation, le programme va voir inc A et va remplacer tout ça par 4
(A vrais dire il va remplacer ça par 00000011 système binaire !!!)

Et peux importe de toute façon le langage utilisé c'est la même chose. En C quand on compile à la fin ce sont des 0 et des 1 compréhensible par le processeur !

Et les langages interprété , (Java?) C'est pareil. Interpréteur va lire l'instruction, et le transformer en binaire pour que la machine puisse comprendre. (C'est plus lent que compiler même si sur nos proco actuel, c'est moins flagrant à voir)

Mais le proco ne sais pas simplement ajouter 1 à un registre ? On serais dans le caca si il y avait que  ça…
Bien sur que non. Il y a beaucoup d'instruction, même dans un proco 8 bits.
Le Z80 permet de transférer la valeur contenue dans un registre dans une case mémoire, faire l'inverse.  Faire des additions, des soustractions. (Mais le z80 ne sais pas multiplier par exemple il faut écrire la « fonction »,  faire des boucle, sauter dans une autre case mémoire, tester un bit contenue dans une case mémoire, faire des rotations de valeurs, ajouter une valeur sur la pile, Modifier A par la valeur contenue dans l'adresse mémoire pointé par le double registre HL (les pointeurssssssss)

Un programme informatique c'est que ça. Déplacement de mémoire.

Décryptage d'un programme Assembleur du Z80
Même pour un proco, il existe plusieurs logiciel d'assembleur. Il existe même des assembleurs pour « compiler » sur une machine A et que cela tourne sur une machine B. (Cross Dev)


Voici un vieux test que j'ai fais il y a plus d'un an. De mémoire et en fonction de mes notes cela permet de faire avancer des battlecharset réalisé en lettre qui ont était redéfini.


L'assembleur que j'ai utilisé demande que chaque ligne soit numéroté comme les anciens basics. D'autre assembleur ne demande pas ça. C'est le premier que j'avais utilité donc je n'ai pas cherché plus loins.

Ligne 10 :
Org &A000
Ceci n'est pas du « code machine » c'est une information qui dit que le programme sera stocké à la case mémoire &A000
&A000 c'est une valeur Hexadécimale. Plus facile à lire que des bits.

20 LD A,0
C'est une ligne qui sera transformer en bits ! LD veux dire pour cette assembleur (et les Z80) Charger. (Load => LD), A c'est le registre de l'accumulateur, et 0 c'est la valeur à placer dans le registre A.  Sur d'autre proco le cela ne sera pas LD mais Move.  ET A peut être représenter par R1 par exemple.
Bon donc la A = 0

30 LD BC,0
Comme la ligne 20, on réunis les deux registre BC et on injecte 0.

40 LD L,(IX )
C'est intéressant ça. IX est entre parenthèse donc c'est un pointeur.
Le registre IX contient une Adresse mémoire. On donc aller à cette adresse mémoire, prendre ça valeur et la charger dans L !

La ligne 50 fait pareil avec H sauf que nous allons chercher à une adresse plus loin que celui contenue dans IX (IX+1)

Concrètement sur ses deux instructions, j'ai du en appelant le programme machine envoyé une valeurs qui s'est logé dans IX pour la ressortir et la travailler ici.

60 BOUCLE. ADD HL,BC
Une belle ligne. BOUCLE. Est une étiquette. ADD HL,BC c'est une adition.
On ajoute à HL le contenue de BC donc la à l'heure actuel on fait HL+0
HL est la réunion des deux registre H et L pour former un registre 16 bit !

70 LD D,H
Simple à comprendre on place le contenue de H dans le registre D
80 LD E,L
Pareil on place le contenue de L dans E

90 LD BC,8
On  place la valeur 8 dans le double registre BC.

100 SBC HL,BC
HL=HL-BC donc une soustraction.

110 LDIR
LDIR est tout simplement une commande pour déplacer plusieurs case mémoires consécutive dans un autre bloc.
On regarde le contenue de HL qui est une adresse, on regarde aussi DE qui est une adresse aussi. On va chercher la valeur à l'adresse pointé par HL, et on la place dans la case mémoire pointé par DE. Ensuite cette commande agrémente de 1 l'adresse contenue dans DE et HL et on décrémente de 1 la valeur contenue dans BC. On continue l’opération jusque que BC=0 Et bomme dans cette exemple BC vaut 8, on fait ça 8 fois.

120 Ld BC,2048
On mémorise dans BC, la valeur 2048 qui correspond à un saut ligne sur l'asmtrad, j'en parlerais plus tard.

130  INC A
On incrémente A
140 CP 8
CP c'est un Test. La on test si A = 8. Si c'est le cas dans le registre F un petit bit se mettre à 1 (je simfplifie

150 NZ,BOUCLE
Si le teste de la ligne 150 est faux on retourne à l'étiquette Boucle (donc on fait ça 8 fois aussi pour 8 lignes)

160 Ret
Retour ! En gros le programme assembleur redonne la main dans l'exemple au programma Basic de l'amstrad.


Voici un petit exemple qui permet donc de déplacer un personnages montrés sur la capture plus haut.

Le langage machine est pratiquement obligatoire sur les vieux ordinateurs, et console pour tirer parti de la puissance des machines surtout au niveau graphismes. Les vieux ordis fut souvent équipé du langage Basic en interprété et la la lenteur se fait sentir considérablement même si il est possible de créer des jeux en 100 % Basic.

Connaître le langage d'un proco n'est pas suffisant pour programmer. Il faut connaître la machine aussi. L'Amstrad et la/le Game Boy possède le même langage mais par la même architecture.
Injecter ce bout de programme dans la game boy aura très certainement d'autre effet que de déplacer  8 lignes verticales sur X pixels à gauche même si le proco va savoir décrypter tout ça.

Le potentiel problème de l'assembleur (et donc du langage machine) c'est qu'il est très peux portable. Plus facile sur les même proco mais quand on change proco c'est terminer !

Pour cela que des langages t'elle que le C par exemple existe par exemple. Beaucoup plus facile pour le programmeur de porter son programme. Enfin presque.


Voilà, c'était un petit paragraphe sur le proco et un le Z80. J'ai simplifié des choses, un peu abus de langage.  Le prochain pavé si il y a toujours des lecteurs qui veulent bien (ça c'est pas sur) c'est la présentation de « L'Amstrad » et un peu de son Hadware.

Voilou.

J'vais tenté de lire tout à l'heure (un peu long lol) ! xD

^^
Voici un autre article pour l'amiga et l'amos sur ça mémoire.
Je dois encore un peu le travailler avant l'envoyer sur obligement.
La rédaction de cette article vient de me permettre de comprendre un peu plus les Banks de mémoire sur le basic amos et avancer sur ce que je veux faire sur l'amiga. ihih

Rem **********************************
Rem * Ne perd pas ta mémoire, Amos est là !  *
Rem **********************************
Rem Par Monos

***************
** Introduction **
***************

  Voici un petit article qui traite la mémoire avec le lanage de programmation  l'Amos.  Enfin  une partie de la mémoire.  L'Amos est un super langage pour l'amiga. Il permet de créer facilement des jeux. (Ou autre application) , il  fait très bien le café à vrais dire mais tout cela a un prix. Il est gourmand en « mémoire » et nous pouvons difficilement gérer ça. J'ai dit difficilement, pas impossible !

  On entend souvent dans d'autres langage de programmation dire : <<C'est lourd, il faut déclarer les variables>>, alors qu'avec l'amos pas besoin. C'est vrais L'amos, et les vieux basic en général pas vraiment besoin de déclarer nos variables contrairement au langage C qui  nous embête à faire ça. Mais c'est quoi déclarer une variable ?

En langage C pour reprendre cette exemple, déclarer une variable c'est réserver de la mémoire pour mémoriser sa valeur ! Si vous avez besoin d'une variable pour entrer une valeur entre 1 et 10, vous allez juste créer une variable avec son espace minimal qui est d'un octet. Pas plus. Mais cette variable ne pourra pas dépasser « 255 ». (En fait le maximum de bits mémorisés dans ce type de variable sera de 8 bits. (11111111), si vous avez besoin d'une plus grande valeur, il faut changer son « typage » tout simplement. Cela veux dire au finale que vous maîtriser l'espace utilisé par vos variables à l'octet prêt.  (Exemple Déplacer une variable type 16 bits. (Int)…) Et donc de la place qu'utilise votre programme.

Avec l'amos, il y a trois types de variables.
Les Integer (Les valeurs rondes sans virgule comme 1,12,98...)
Les Real (Ou Float, enfin valeur avec des virgules 10,2  8,5)
et les Strings (Chaîne de caractères, pas les sous vêtements féminin)

La place que prend la variables « strings » dépend de son contenue.
La place que prend les deux autres type de variable numérique que cela soit des Integer ou Real, c'est 4 octets. Vous voulez placer seulement la valeur 2 dans une variables, ba c'est 4 octets quand même.  Bonjour la gestion de la mémoire !!!

Et pour les tableaux c'est pareil on multiplie la valeurs maximum des dimensions + 1 (Car oui il ne faut pas oublier la case 0) et on multiplie par 4 octets. (Les cases des tableaux de chaîne sont variables.)
Exemple un tableau Dim Tb(99,99) = 100*100*4=40000 octets (40k)
Outch. Cela commence à peser lourd.
Ce n'est pas dramatique non plus, les amiga on quand même de la mémoire. 512/1024/2048 Ko suivant les versions sans ajout de mémoire externe. Nous sommes loin des 64Ko du C64 . Mais bon, gagner de la place il le faut. En plus de ça il faut ajouter la place mémoire des icones, , des fenêtr, des Bobs, (Tain, c'est moi Bob, Strings, Bits.. Non j'ai rien dit)

Tenez pour une fenêtre à afficher. Voici la formule mathématique pour savoir combien ça pompe !
(Hauteur x Largeur x coef du plan)/8
Le coefficient du plan est :
1 pour une fenêtre de 2 couleurs
2 pour une fenêtre de 4 couleurs
3 pour une fenêtre de 8 couleurs
4 pour une fenêtre de 16 couleurs
5 pour une fenêtre de 32 couleurs
6 pour une fenêtre de 64 ou de 4096 couleurs.

Donc pour du 320x256 en 16 couleurs cela nous donnes :
(320*256*4)/8 = 40960 octets.
Faite le calcule pour de plus grande fenêtre…
Bon je fais cette articles non pas pour dire 'bouh l'amos c'est nul '. Mais pour montrer une autre zone de variable à travailler et qui peut être utile pour plein de chose. Travailler directement dans la mémoire de votre amiga ! Ne vous inquiétez pas, on ne vas pas parler de Langage Machine à proprement parlé. Juste de la mémoire.

************
** La Base **
************
Bon avant de partir nous allons voir une petite base. C'est quoi la mémoire d'un ordinateur (en général).

- La mémoire est un endroit ou nous pouvons stocker des valeurs numériques. Seulement des valeurs numérique s! Le texte est transformé en valeur numérique avant d'être stocké dans la case mémoire ! (En principe une case mémoire par lettre.)

- La mémoire d'un ordinateur c'est comme un tableau, elle est découpée en Case !

- Une case permet de mémoriser une valeur entre 0 et 255

- Chaque case porte un numéro entre 0 à x(cases) qui représente son adresse. (C'est virtuel hein, ce n'est pas gravé dessus)

- En informatique on travaille le plus souvent sous  3 formes d'écritures pour les valeurs.
  -La base de 2. Soit c'est 0 soit c'est 1. Le système Binaire.
  -La base de 16 noté avec nos chiffre entre 0 et 9 + complété  avec des lettres de A => F . C'est le    système Hexadécimal.
  -La base de 10 que nous connaissons tous.  Notre système Décimale !

Trois autres terme technique important !
=>Un Bit, c'est le système binaire. C'est soit 0 ou 1. Bit avec un « i »
=>Un Octet, c'est la réunions de 8 bits. En système décimale un octet est donc une valeur entre 0 et 255. Donc une case mémoire vaut 1 octet
=>Un Byte. Avec un «y » Attention à celui la. Souvent cela veut dire 1 Octet (8 bits) dans beaucoup de système informatique. Mais ce n'est pas toujours le cas. Voici l'introduction de l'article sur Wilkipedia. 

Le byte (prononcé [baɪt]), anglicisme de symbole B, ou multiplet, est la plus petite unité adressable d’un ordinateur. Aujourd’hui, les bytes de 8 bits se sont généralisés en informatique, alors qu’en télécommunications ils peuvent contenir 8 ou 9 bits. Mais jusque dans les années 1970, il existait des processeurs avec des bytes de 6, 7, 8 ou 9 bits, et il existe aujourd'hui pour la programmation des automates ou équipements industriels simples des processeurs très robustes utilisant des mémoires adressables par quantité de 4 bits voire 1 bit. En revanche, un octet, comme son nom l’indique, est un byte d'exactement 8 bits (en anglais eight-bit byte).
https://fr.wikipedia.org/wiki/Byte

***************
** Peek et Poke **
***************
Ah ah les personnes qui ont travaillé sur du 8 bits connaissent ce couple oh combien important pour programmer. Le Poke (qui permet d’injecter une valeur dans la mémoire) et son copain Peek (Qui fait l'inverse permet de lire une valeur d'une case mémoire)
Utilité sur les 8 bits ? Injecter du code machine directement en basic dans la mémoire ou le plus souvent s'adresser à la mémoire vidéo. Tricher aussi sur les jeux non ?

Le basic amos possède aussi ses deux fonctions, chouette non ? Un petit test , lire la premier case mémoire et voir sa valeur.
Voici donc les deux fonctions de base à connaître pour lire et écrire une valeurs en mémoire.


Peek(Adreesse) 
exemple : Peek(12)

Poke adresse,valeur
exemple : Poke 12,255

Attention à ne pas poker partout, car ça peux faire de l'instabilité….
Fait un truc du genre :

For X =0 to 65
Poke X,255
Next

Promis vous avez des chances de faire badaboom ! L'amiga va se bloquer un petit reset ?

Nous allons faire plus ou moins un abus de langage et vulgarisation technique de l'amiga.
Contrairement au machine 8bits, l'os de l'amiga tous comme Windows microsoft travaille dynamiquement sa mémoire. En gros ta besoin de mémoriser une variable, l'os dit ! attend mon coco, je te prépare une adresse ou tu peux foutre ton chiffre, Voici l'adresse, entre temps, un autre programme sollicite l'os, notre ami répond : toi tu as besoin d'un espace pour mémoriser ça, j'ai cette case mémoire pour toi qui est libre, tu la prends. Bref en gros c'est pas vraiment vous qui décidé ou foutre vos donnez. C'est L'OS ! C'est le chef d’orchestre.

Quand vous utilisez une variable sur l'amos, c'est pareil, L'amos et l'os collabore pour trouver des espaces libres mais ce n'est  pas vous qui  les choisissez. Alors pour travailler votre mémoire manuellement comme nous voulons le faire cela peut être compliqué, car si vous utilisez une case mémoire qui est réservé pour un autre programme,  ba Badaboom quoi. (Il y en a qui en essayé, mais ils ont eu des problèmes!)

Donc ce que nous allons faire c'est de dire à notre super os préféré de réserver de l'espace pour nous ! Bien à nous, pour que personne d'autre puisse y toucher ! Et l'amos sait le faire. C'est les fameuses Bank de mémoire ! Et oui , si vous utilisez des musiques, des bobs, des sprites, les icones… Vous faites cela. Indirectement mais c'est la même chose.

L'amos professionnel peux réserver 65535 bank de mémoire différentes.
Attention les 4 premiers sont réserves pour  des utilisations natives à l'amos.
La Bank 1 est pour les Sprites
La Bank 2 est pour les icones
La Bank 3 est pour les musiques
La bank 4 est pour le système Amal.

Il faut savoir un autre truc aussi, Il existe deux types de Bank.
Les Banks de type Data. Qui est une bank de mémoire qui reste en mémoire dans l'éditeur de l'amos. (Comme les Objets et Icones par exemple).

Et les Banks de type Works (Travaille) qui est volatile. Les donnés sont zapés une fois le programme terminé.

Ah et il y a deux types de mémoire aussi , le Chip et la Fast. La c'est lié à l'hardware de l'amiga.
Souvent la Fast mémoire provient des extensions de mémoire.
Print Fast Free et Print Chip Free permet de voir ce que vous avez. (En octet).
Bon pour cette exemple nous allons travailler des données pour un joueur.
Ça position X, ça position Y, et son nombre de PV
Ce qui nous fait donc trois variables théorique. Soit 12 octets avec le système du basic.
En passant par les cases mémoires, cela ne fait que 3 octets. (Si on ne dépasse pas 255 bien sur)

Nous allons donc réserver un espace de travaille de 3 octets.
La  formule est :
Reserve As Work numéros_de_bank, longueur
Reserve As Work 10, 3

Remplacer Work par Data si vous voulez que ça reste en mémoire dans le code source comme les icones, les objets...
Oh, voila l'os amiga vient de nous réserver 3 octets pour nous. Aucune autre programme ne devrais y toucher. Si il est bien fait bien sur.
Nous allons pouvoir pooker et peeker dedans chouette non. Mais avant il faut savoir ou se trouve nos trois octets que l'os nous a réservés.

Ba nous avons une fonction pour ça en amos.

Start(Numeros_bank)
print Start(10) devrait nous donner l'adresse de départ des trois octets que nous avons réserves.
On va vérifier la contenue des trois adresses pour voir si ça contient un truc.
(Note : 10 c'est notre exemple car on a réservé la bank 10, si vous utilisez la bank 50, ba c'est 50 heins par 10.)

For X=0 to 2
print peek(Start(10)+X)
Next

Voilà une belle routine de lecture pour nos trois octets.
Maintenant nous pouvons la travailler avec Poke.
On va dire qu'il se trouve au coordonner 12/14 avec 99PV

Donc on va faire :

Rem ** Travaille sur la bank **

Rem Reserver la bank 10 avec 3 octets
Reserve As Work 10,3

Rem Adresse de départ de la bank 10 pour voir un peu ou c'est.
Print Start(10)

Rem Mémorisation. Le +1,+2 permet d'aller à une autre case mémoire
Poke Start(10),12
Poke Start(10)+1,14
Poke Start(10)+2,99

Rem Lecture
For X=0 to 2
print peek(Start(10)+X)
Next

A la lecture des cases mémoires, nous avons bien les valeurs enregistrés.
Bien nous pouvons mémoriser l'adresse de départ ''Start(10)'' dans une variable pour plus de commodité. Il faudra faire Poke Variable,12 : Poke Variable+4,14….
Il y a d'autre types pour enregistrer tout ça.

*********************
** Sauvegarder la bank **
*********************
Il existe deux méthodes pour sauvegarder une bank.
Methode simple : Save ''Nom.abk'',numeros_bank
Boom, la bank que vous voulez est sauvegarder. L’extension ABK indique que c'est une bank de mémoire. Dans notre exemple je peux faire.
Save ''PJ.abk'',10
Et pour son chargement je fais un simple load ''PJ.abk'' ,10
Tada sauf qu'il y a un petit problème. Dans mon exemple pour 3 octets, ça sauvegarde un fichier de  23 octets. Il y a un Header dans le fichier avec des informations qui alourdit un peu la note. (Numéro bank, type de bank, ...)

Nous pouvons économiser le Header avec la commande Bsave (et Bload)
Bsave ''Fichier.ce_que_vous_voulez', adresse_début TO Adresse de fin
donc
BSAVE ''PJ.BIN'',Start(10) TO Start(10)+3
(Note pour 3 octets cette fois si c'est belle et bien Adresse +3 et non +2)
Et voila, un beau fichier de 3 octets

Au chargement un Bload ''PJ.BIN'',Start(10)
en ayant réserver une bank numéro 10 de 3 octets, et le tour est joué !

********************
** D'autre commande **
********************

L'amos présente d'autre commande dans son arsenal sommairement en voici qu'elle que une.

Erase numeros_bank
Permet d'effacer une bank en mémoire.

Erase All
Permet d'effacer toutes les banks en mémoire.

Erase temps
Efface les banks de type Works

List Bank
Liste les banks ave le format suivant :
Numeros bank, C ou F (Chip/Fast) , Type, Adresse de départ , Longueur

La fonction Lenght(Numeros_Bank) permet de connaître la longueur de la bank.
************************************
** D'autre Fonction de lecture / Ecriture ! **
************************************
L'amiga n'est pas une machine 8 bits. Elle est capable de manipuler des grands nombres voici d'autre fonction à connaître pour travailler la mémoire.
Il est possible de lire une valeur sur deux octets.
Un petit
print Deek(start (10))
et cela va nous afficher dans notre exemple la valeur 3086. (Et non 1214 ou 1412)
Les deux octets sont considérés comme une seule valeur de 16 bits. (Il n'y pas de notion de poids faible et de poids fort, oubliez si vous ne savez ce que cela veux dire)
La fonction inverse pour poker une valeur 16 bits c'est
Doke,adresse,valeur
Cette fois si nous ne sommes pas limité entre 0 et 255 mais entre 0 et 65535
Et Leek et Loke permet lui de travailler sur 4 octets, comme les variables du basic.
********************
** Bin/Hexa/Décimal **
********************
Nous parlons mémoire mais si je ne parle pas de nos trois systèmes de Base cela ne va pas le faire.
Un moment ou un autre vous allez être bloqué.

Débutons avec le système Décimal. C'est celui que nous connaissons le plus, car nous l'utilisons à 99 % dans la vie de tous les jours.
Le Système Décimal contient 10 valeurs numériques.
=>0,1,2,3,4,5,6,7,8,9
Une fois à 9 pour aller plus loin on repasser à 0 et on ajoute 1 au chiffre qui se trouve à sa Gauche.
Donc 10, puis 11,12,13,14,15,16,17,18,19
On fait de même avec 20,30,40,50,60,70,80,90
Et à 99 on replace le chiffre à 0, on ajoute 1 au chiffre à gauche, comme c'est un 9 on le replace aussi à 0 et on ajoute 1 au chiffre à gauche ce qui fait 100.

Vous devez rigoler en lisant cela. C'est tellement naturel pour nous, mais ce que je viens d'expliquer c'est un socle commun pour toutes les bases !

Voyons le système binaire qui contient que deux valeurs. 0 et 1. Nous allons utiliser la même méthode  que le système décimale.
On ajoute 1 à notre chiffre. Si la valeur avant l’addition est à son maximum, on revient à sa valeur minimum possible et on ajoute 1 au chiffre de sa gauche, et on continue !!!
Donc
0-1
Nous sommes au maximum et si on rajoute 1 ?
On repasse à 0 et on ajoute 1 au chiffre de gauche et comme c'est 0 ba ça vaut 1.
10-11
100-101-110-111
1000-1001-1010-1010-1100-1101-1111
…

Et l'hexadécimal ?
C'est pareil ! L'hexadécimal c'est une Base de 16.
On l’écrit avec des chiffres et des lettres.
0 => 0
1 => 1
2=> 2
3=> 3
4=>4
5=>5
6=>6
7=>7
8=>8
9=>9
10=>A
11=>B
12=>C
13=>D
14=>E
15=>F

16 valeurs.
0 le minimum et F le maximum. Comme les autres bases une fois à F et que nous ajoutons 1. On repasser à 0 et on ajoute 1 au chiffre de Gauche.
F+1=10
FF+1=100
EFF+1=F00
…

Trois bases. Donc nous savons 1 octet = 8 bits=255 en décimal=FF en hexadécimal.
Petit fait amusant, dans nos 8 bits on peux les découper en 2 . 4 bits et 4 bits. Ba c'est pareil en hexadécimal. 4 Bits = 16 en décimal. F=16 Décimal.
C'est pour cela que l’hexadécimal est pratique. Nous pouvons lire facilement les 4 premiers bits et les 4 seconds bits. Pratique quand nous devons découper un octet non ?
(Exemple 11110111, ceci est un octet qui représente une valeur de  247, en Hexadécimale cela fait  F7 , si je découpe F= 16, et 7 ba la c'est 7. Regardons nos 4 premiers bits. 1111 cela fait bien 16 donc F. Et les 4 suivant. 0111 cela fait 7, donc 7 en héxa et 7 en décimale du coup. Voilà )

************************
** Conversion avec l'amos **
************************
C'est bien beau, maintenant que vous connaissez la base si vous partez de rien, l'amos possède des fonctions pour convertir les trois systèmes.

Quand vous écrivez un truc du genre
print 10+2
l'amos sait très bien que vous travaillez en système Décimal.
Idem pour les variables, et pour utiliser peek et poke. L'amos fait les conversions tout seul.
Mais voila des fois il faut travailler dans les deux autres bases et savoir convertir tout ça.

Je voudrais savoir comment écrire 2 en système binaire !
La fonction est Bin$(Valeur)
Petit piège,  pour faire apparaître la valeur binaire, il faut utiliser les chaîne de caractère.
B$=Bin$(2)
Print B$
=>%10
Sur l'amos un « chiffre binaire » est précédé par le sigle des pourcentages (%). C'est la convention sur l'amos. Cette convention peut changer suivant les langages, les assembleurs, les tutos…

Et l'inverse ? Je sais que %10 = 2 mais j'ai besoin de la placer dans une variable ?
Regarder cette exemple :

B$ = ''%10'' : Rem on mémorise %10 en tant que chaîne dans la variable B$
Print B$ : Rem On vérifie ça annonce bien %10 ;
Print Val(B$) : Rem Oh magie, ça affiche 2
Donc un D=Val(B$) ou D=Val(''%10'') va bien convertir la chaîne %10 en valeur numérique.
Ceci dit faire tout cela directement fonctionne.
B=%10
Donne Bien 2 à B
Notons que dans peek et poke nous pouvons utiliser directement l'écriture %10 sans utiliser Val. (Toute les fonctions d'ailleurs c'est juste pour lire directement une valeur binaire qu'il faut passer par les strings.)

Pour l'Hexadécimal c'est pareil. Au lieu d'être Bin$ c'est Hex$
Le sigle avec l'amos pour l'écriture Hexadécimal c'est le dollar comme les strings.
$FF pour 255.
Les règles sont les mêmes pour le système binaire.

Petite note, Bin$(Valeur,X)
X permet de sortir les X bits a partir de la droite.
Cela marche pareil avec Hex$
Exemple :
B=%1000
Print Bin$(B,2)
=>%00
Car les deux bits de droite c'est 0

******************
** Allons plus loin **
******************
Bon c'est bien beau, j'ai parlé de bank mémoire, sa petite manipulation, Les trois bases  qui sont utilisés majoritairement en informatique, mais pour quoi faire concrètement ?

Exemple en pagaille :
-Son système de sauvegarde ! Simple et rapide !
L'idée est toute simple. Les données à mémoriser ne sont pas dans les variables du basic mais directement dans une bank de donnée. Comme ça au moment de la sauvegarde et du chargement, tout est prêt. Cela évite des boucles pour placer / déplacer les valeurs dans variables<=>Adresse, ou  Variables <=> Fichier. Un gain de temps , de programmation, mais une bonne dose d'organisation !!!

-Gagner de la place mémoire en général.
L'exemple du tableau, je veux faire une Map de 100 cases sur 100 cases, pour mémoriser cette map, je place l'id des tuiles dans un tableau. Comme ça je sais qu'en 0-0 ça me donne la tuile 6 et j'affiche en 0-0 la tuiles 6. C'est pratique mais voila gourmand en place mémoire.
100*100*4 en octet ce qui fait environs 40Ko de mémoire.
Imaginé tout ça en bank de mémoire…. Le même rapport 100 cases sur 100 case on ne le multiplie pas par 4 mais on garde seulement la case d'octet. 10Ko de mémoire pour la map ! (Un vrais gain non ?)
On plus on peux facilement décharger/charger des maps en mémoire avec le même système que les sauvegardes ! Pas belle la vie. Bien sur il faut faire une routine pour savoir reposer les tiles/ se positionner au bon endroit du tableau, bref il y a quand même un peu de boulot.

-Décomposer un octet !
Nous avons que 16 tiles dans notre jeu. Cela sera bête d'utiliser 1 octet complet pour mémoriser seulement une case mémoire. On peux bien  sur  utiliser les 4 premiers bits pour le 1er tiles et les 4 seconds pour le 2nd.
Plusieurs méthodes, vous vous souvenez l'histoire des Hexadécimal  avec le binaire ?
Un octet c'est deux chiffres Héxa, on les décomposant, on peux avoir la premier partie d'un tiles puis l'autre… Pratique.
On peux créer aussi des routines ou les maps sont codés sur 7 bits et le 8em donne l’information si on peux ou pas marcher ou pas sur sur ce tiles.
La fonction BTST(Valeur, Numéro_Bit)
permet simplement de tester si un bit vaut 0 ou -1(Ce qui veux dire 1)
Le numéros des bits vont de 0 à 7 en partant de droite.


Voilà vous avez toutes les cartes en main pour exploiter directement la mémoire de votre amiga avec l'amos et économiser un peu de place.

Vous pouvez retrouver d'autre information au pages
05,09,01(Memory Bank) et 14,A,01 (Code Machine) du manuel Amos professionnel 

Monos

Impressionnant le nombre de ligne,en tout cas ca me rappelle de très bon souvenir.
Bref trèèèèèès très bon article. :bravos

Amiga 500, atari st, to7... j'ai l'impression que c'était hier ! Super article Monos !

Merci. Depuis hier je suis sur cette technique de mémoire pour économiser de la plus. Plus le temps passe, plus j'ai l'impression que les programmeurs s'en foute royalement. Hier j'ai testé un nouveau ide de langage de programmation en basic prévus pour du multiplateforme.  App Game Kit (les mêmes créateurs que le dark basic qui est passé gratuit et open source pour information). Ba j'ai eu peur au moment de la compilation. Une simple fenêtre l'application PC et APK, 20 Mo.
Je parle pas de la taille des "sites web" qui grimpe en flèche.

M'enfin bon hier après la rédaction de l'article sur la mémoire/place j'ai bosser des algos. Le but est de mémoriser des cartes d'un RPG à la ultima. Comme dit l'article, une map de 100 carreaux sur 100 c'est 40ko de mémoire et sur un fichier c'est pareil. C'est beaucoup trop pour un amiga même si potentiellement nous avons les 512ko.

L'algorythme que j'ai trouvé est la suivante qui peux même servir sur fusion.
Mon exemple est une map de 9 carreaux sur 9 carreaux, le sprite du héro est toujours afficher au centre de la "map"

Adresse_de_Départ = (Position_Y_Joueur-4)x100+Position_X_Joueur-4
  Boucler tant que Map_Y est compris entre 0 et 8 (Boucle For)
  Boucler tant que Map_X est compris en 0 et 8
    Numéros_Tiles=Au contenue d'adresse numéros (Adresse_de_Départ+Map_X+Map_Y*100)
    Afficher l'image en rapport du numéros_Tiles à la position X=Map_X*16,et la position Y=Map_Y*16
  Ajouter 1 à MapX, Ajouter 1 à Map Y

Maintenant je réfléchie comment coder mon tiles.
J'ai un octet de disponible. L'idée premier est le numéros du tiles sur les 7 premiers bits et le 8em défini si la case peut être franchis (0) ou est infranchissable (1) ce qui me donne un choix de 128 Tiles (7 bits)

Au début je pensais faire ça sur 6 bits (64 tiles) et voir ce que je peux faire des deux derniers bits.