www.cpcalive.com
Click here for english documentation
Pulsar aquí para la documentación en español
* CpcAlive V1.08M *  DOCUMENTATION (V0.3) *

notes:
- Cette documentation ne concerne que les informations nécessaires à l'utilisation de l'émulateur CpcAlive. Des documentations sur l'exploitation du Cpc et sur les interruptions Bios et Dos, des programmes utilitaires, un assembleur Z80 ainsi qu'un assembleur X86 sont disponibles sur le site internet: www.cpcalive.com
- L'auteur de cette documentation a utilisé deux types de notation des valeurs hexadécimales. La première notation est celle utilisée par le Cpc qui ajoute le signe "&" devant la valeur, ex:&3F. La deuxième notation ajoute la lettre "h" derrière la valeur, ex:3Fh.

SOMMAIRE

I - Présentation et installation de l'émulateur CpcAlive
II - Commandes CpcAlive à partir de la ligne de commande Dos:
        CpcAlive [fichiers_d_entrée[:X]] [commandes CpcAlive] [commandes Cpc] [>fichier_de_sortie]
    - 1 - Fichiers d'entrée
        - 1a - Chargement des disquettes virtuelles au format .DSK -
        - 1b - Chargement des ROMs CPC -
        - 1c - Chargement de fichiers au format intel hex  -
        - 1d - Chargement de fichiers de commandes CpcAlive
        - 1e - Chargement de fichiers au format texte
        - 1f - Chargement de fichiers binaires
    - 2 - Commandes Cpc depuis la ligne de commande du Dos
     - 3 - Fichiers de sortie
III - Commandes CpcAlive à partir de l'interpréteur basic du CPC
 IV - CARACTèRES ACCENTUéS
 V - ACCES AUX INTERRUPTIONS DU BIOS ET DU DOS VIA Z80
VI - ENVIRONNEMENT X86
 VII - PROGRAMMES UTILITAIRES
    - 1 - CreaDisc: Crée une disquette virtuelle vierge au format data.
    - 2 - AniCrea.exe: Crée un fichier d'animation au format .FLI
    - 3 - Fli2Gif.exe: Pour lire un fichier d'animation au format .FLI (entre autre)
    - 4 - Disquette de démarrage CpcAlive
    - 5 - CD de démarrage CpcAlive


                                                                                                                                                                                                                      

I - Présentation et installation de l'émulateur CpcAlive:

CpcAlive est un émulateur d'ordinateur Amstrad CPC 6128. Un des intérêts de cet émulateur étant d'enregistrer les images de l'écran afin de créer des fichiers d'animations graphiques.

 Spécificités de l'émulateur CpcAlive:
* environnement de programmation X86 (16Mo)
* accès interruptions Bios et Dos via instructions Z80
* sorties écran au format BMP et animations FLI
* palette 262144 couleurs
* gestion clavier intégrée au clavier PC de manière automatique.
* émulation clavier à partir d'un fichier texte
* possibilité de traiter à partir de l'interpréteur basic du Cpc, tout fichier présent sur le disque dur ou autre support.
* les programmes Cpc peuvent êtres utilisés en filtres et êtres intégrés dans un fichier .BAT (sortie de l'émulateur par commande basic)
* intègre un débuggeur Z80
* compatibilité: - Dos,Windows 95/98/2000/Me/XP
                       - processeurs 386 et plus..

Lors de l'installation, un icône de lancement de l'émulateur est déposé sur le bureau de Windows. Pour commander l'émulateur à partir de la ligne de commande du system Dos, utiliser le bouton "démarrer" de Windows situé en bas à gauche de l'écran, puis ouvrir le menus d'accès aux programmes en cliquant sur "Tous les programmes", puis "CpcAlive". Un menu s'affiche comprenant, entre autres, un icône de lancement de l'émulateur CpcAlive, un icône de lancement du système Dos sous Windows XP ainsi qu'un icône de lancement du système Dos pour les systèmes Windows 95 et 98. Les divers programmes utilitaires fournis avec l'émulateur CpcAlive sont accesssibles à partir de la ligne de commande du Dos.

= Icône de lancement de l'émulateur CpcAlive
= Icône de lancement du système Dos sous Windows

Remarques:
       - Les roms Amstrad ont un copyright, tu ne peux donc normalement utiliser le programme CpcAlive seulement si tu possèdes un ordinateur Amstrad Cpc 6128 en état de fonctionner.
       - Les couleurs PAPER et PEN 1 ont été modifiées à l'initialisation pour des raisons d'ergonomie (moins fatiguantes pour les yeux).


II - Commandes à partir de la ligne de commande Dos:

CpcAlive [fichiers_d_entrée[:X]] [commandes CpcAlive] [commandes Cpc] [>fichier_de_sortie]
ou
! [fichiers_d_entrée[:X]] [commandes CpcAlive] [commandesCpc] [>fichier_de_sortie]


- 1 - Fichiers d'entrée
~~~~~~~~~~~~~~~~~~~~~
Les fichiers reconnus par l'émulateur sont:

Disquettes virtuelles au format .DSK ( voir chapitre - 1a - )
Fichiers Roms Cpc                          ( voir chapitre - 1b - )
Fichiers au format intel hex              ( voir chapitre - 1c - )
Fichiers de commandes Cpcalive      ( voir chapitre - 1d - )
Documents textes                            ( voir chapitre - 1e - )
Fichiers binaires                              ( voir chapitre - 1f - )

Chargement à partir de la ligne de commande du Dos:
CpcAlive NomDeFichier[:X]
Il est aussi possible d'utiliser la syntaxe: ! NomDeFichier[:X]

La lettre représentée par le caractère X est facultative, elle dépend du type de fichier à charger. Elle sera appelée "marqueur" et devra être tapée en majuscule. (Ne pas mettre d'espace entre le nom de fichier et le marqueur.)

Chargement à partir d'un fichier de commande CpcAlive:
NomDeFichier[:X]

Chargement à partir de l'interpéteur basic du Cpc:
|INPUT,"NomDeFichier[:X]"[,@er%]

Le paramètre de retour d'erreur @er% est faculatif. S'il est mis, la signification des valeurs récupérées dans la variable er% sont:
       
        0 = ok
        1 = erreur dans les paramètres
        2 = chemin non trouvé

Ne pas oublier d'initialiser er% au départ du programme ou avant la commande. La barre verticale présente devant la commande INPUT est obtenue en actionnant en même temps la touche [AltGr] et la touche [6] située en haut du clavier.

ex:    10 er%=0
        20 |INPUT,"Disque.dsk:A",@er%
        30 if er%<>0 then PRINT"ERREUR":STOP

Il est possible de mettre plusieurs noms de fichiers à la suite, il suffit de les séparer d'un espace. Dans ce cas, le code d'erreur er% concernera seulement le dernier fichier mentionné.


- 1a - Chargement des disquettes virtuelles au format .DSK -

Faire suivre le nom de fichier du marqueur :A ou :B pour choisir le lecteur destination. (lecteur A par défaut)

Exemples:

Pour charger une disquette virtuelle dans le lecteur A:

Chargement à partir de la ligne de commande du Dos:
! NomDeDisquette:A
Chargement à partir d'un fichier de commande CpcAlive:
NomDeDisquette:A
Chargement à partir de l'interpéteur basic du Cpc:
|INPUT,"NomDeDisquette:A"


- 1b - Chargement des ROMs CPC -

Le Cpc 6128 est pourvu en standard de 48Ko (3 blocs de 16Ko chacun) de mémoires ROM.
Un de ces blocs contient le système d'exploitation (bios) qui se connecte dans la zone 0 à 03FFFh (rom inférieure). Les deux autres blocs (BASIC et système disque) se connectent dans la zone 0C000h à 0FFFFh (roms supérieures). Le système peut exploiter dans cette dernière zone 252 blocs de 16Ko chacun. Une particularité intéressante de ces roms est qu'elles peuvent recevoir des instructions BASIC programmables (Resident System eXtension).

Pour charger une rom supérieure dans l'émulateur, faire suivre le nom de fichier du marqueur :R . L'émulateur recherchera le premier emplacement disponible. Le fichier peut être au format binaire ou au format intel hex.

Chargement à partir de la ligne de commande du Dos:
! Z80ROM.ROM:R
Chargement à partir d'un fichier de commande CpcAlive:
Z80ROM.ROM:R
Chargement à partir de l'interpéteur basic du Cpc:
 |INPUT,"Z80ROM.ROM:R":call 0

Au cas il est nécessaire d'avoir un numéro d'emplacement fixe, remplacer la lettre "R" par le numéro d'emplacement désiré.
Exemple à partir de la ligne de commande du dos: ! Z80ROM.ROM:10

 Les roms ne seront reconnues par le système Cpc seulement après une réinitialisation du Cpc par exemple avec un CALL 0 ou en actionnant la séquence de touches [CTRL][ALT][Home]. L'émulateur accepte des instructions RSX dans la totalités des roms supérieures. Les numéros de roms supérieures déja utilisés par le Cpc sont 0 pour la rom basic et 7 pour la rom disque. Les modules X86 (voir chapitre "Environnement X86") intégrants des mnémoniques utilisent aussi des emplacements de roms Z80. Les roms Z80 avec un  numéro d'emplacement spécifique doivent donc être chargées avant les modules X86, le meilleur moyen d'éviter les conflits étant de les charger au début du fichier de commandes ROM.INI situé dans le répertoire principal.

note:
- Les marqueurs doivent être indiqués en majuscules

 Exemple de création d'une ROM contenant des instructions BASIC programmables (Resident System eXtension)


- 1c - Chargement de fichiers au format intel hex  -

Un fichier au format intel hex est un document texte composé de lignes au format intel hex.

Représentation d'une ligne au format intel hex:
:LLAAAA00DDDDCC     ; ' : ' = caractère de départ
                                       ; LL = taille bloc (2 digits hexa)
                                       ; AAAA = adresse de départ (4 digits hexa)
                                       ; 00 = type d'enregistrement (00)
                                       ; DDDD = données (2 digits hexa pour chaque octet de données)
                                       ; CC = crc ligne (2 digits hexa)
                                       ;       = -(somme de tous les octets de la ligne) and 0ffh
exemple:
:18A600000109A62111A6C3D1BC15A6C31EA6C335A6000000004F5049A2
:18A61800D8495049D800DD5603DD5E02DD4605DD4E043E0C4052DD7E97
:18A6300000404810C9D5DD5603DD5E02DD4605DD4E043E0D40524048AD
:07A6480010D11213AF12C97B
:00000001FF

Dans cet exemple, la première ligne contient 018h octets de données (01h,09h,0A6h...049h) qui seront chargées à partir de l'adresse 0A600h. Le crc de la ligne est égal à 0A2h. L'émulateur ignore le crc (Checksum) normalement présent à chaque fin de ligne dans le standard Intel Hex. Noter le type d'enregistrement égal à 1 indiquant la dernière ligne du fichier. Cette ligne n'est pas nécessaire dans les fichiers chargés par l'émulateur.


Chargement en rom:

 Pour charger un fichier au format intel hex en rom, faire suivre le nom de fichier du marqueur :X où X représente le numéro de rom destinataire. Par exemple pour charger dans la rom numéro 10:
Chargement à partir de la ligne de commande du Dos:
! FICHIER.HEX:10
Chargement à partir d'un fichier de commande CpcAlive:
FICHIER.HEX:10
Chargement à partir de l'interpéteur basic du Cpc:
 |INPUT,"FICHIER.HEX:10"

Si la rom destinataire n'existe pas, CpcAlive la crée, il est alors possible d'utiliser le marqueur :R (voir chapitre "Chargement roms Cpc")
            

Chargement en ram:

Le Cpc 6128 possède une mémoire RAM de 128Ko divisés en huit blocs de 16 Ko chacun, numérotés de 0 à 7. Seul quatre blocs peuvent êtres connectés simultanément.

valeur port &7F      position blocs
                &C0          0,1,2,3            <= configuration standard
                &C1          0,1,2,7
                &C2          4,5,6,7
                &C3          0,3,2,7
                &C4          0,4,2,3
                &C5          0,5,2,3
                &C6          0,6,2,3
                &C7          0,7,2,3

Le système du Cpc n'exploite que le premier type de configuration. Dans cette configuration le bloc 0 occupe l'espace 0 à 03FFFh de la mémoire, le bloc 1 l'espace 04000h à 07FFFh, le bloc 2 l'espace 08000h à 0BFFFh, le bloc 3 l'espace 0C000h à 0FFFFh. L'écran exploite le bloc 3. La partie supérieure du bloc 2 contient les variables système. La partie inférieure du bloc 0 est utilisée par le système. Les programmes Basic sont chargés par le système à partir de l'adresse 0170h. Les données binaires peuvent êtres chargées à partir de l'adresse définie à l'aide de la commande Basic "MEMORY". S'il s'agit de programmes exécutables, ils pourront être appelés grâce à l'instruction "CALL".

Pour charger un fichier au format intel hex en ram, faire suivre le nom de fichier du marqueur :X où X représente le type de configuration de la ram destinataire.

Les valeurs hexadécimales valides pour le chargement en ram sont:
                0C0h,0C1h,0C2h,0C3h,0C4h,0C5h,0C6h et 0C7h

Par défaut, le chargement se fait en ram avec la configuration 0C0h.
exemple à partir de l'interpréteur basic du Cpc:
|input,"fichier.hex"
Dans ce cas, le fichier "fichier.hex" est chargé en mémoire avec la configuration standard.

notes:
- Il est possible de visualiser la mémoire du Cpc avec l'émulateur CpcAlive en utilisant la commande |DEBUG,&f à partir de l'interpréteur basic.
- Charger des données en ram dans les blocs 0,1,2 ou 3 avant l'initialisation du système Cpc est inutile puisque celle-ci est effacée au démarrage. Pour charger des données en ram à partir de la ligne de commande du Dos, il faut que le système ait été lancé puis mis en veille auparavant.       
- Les marqueurs doivent être indiqués en majuscules


                                                                                                                                                                                                                      
note: L'assembleur 8 bits "tasm" génère des fichiers au format Intel Hex. Cet assembleur est disponible en téléchargement sur le site internet: www.cpcalive.com
                                                                                                                                                                                                                      


- 1d - Chargement de fichiers de commandes CpcAlive

Les commandes internes de l'émulateur valides à partir de la ligne de commande du système Dos ou d'un fichier de commandes CpcAlive sont:

CpuFast                    ; instaure la vitesse maximum (par défaut)
CpuSlow                   ; instaure la vitesse normale (vitesse de l'ordinateur Cpc)
Sleep                        ; pour mettre en veille l'émulateur         [AltGr][S]
Exit                          ; pour quitter l'émulateur                          [Ctrl][Alt][Fin]
ROM=X                   ; pour sélectionner une rom supérieure (X=0à255)
                                ; (X=256 pour sélectionner la rom Bios du Cpc)
RAM=X                   ; pour sélectionner un type de RAM
                                ; voir chapitre II - 1c - "Chargement en ram"
                                ; pour les valeurs de configuration disponibles.
:LLAAAA00DDDD   ; chargement données (ligne au format intel hex)
CommandEnd (ou EndCde) ; Indique la fin d'un fichier de commande. (facultatif)
 KeyBoard                 ; Pour passer du mode "commandes CpcAlive" au mode "émulation clavier". Il sera possible de rétablir l'interprétation du fichier en mode "commande" grâce à l'instruction |COMMAND.
Les commandes CommandEnd, EndCde et KeyBoard rétablissent la configuration mémoire du Cpc effective au lancement du fichier de commandes ou de la séquence de commandes.


exemple à partir de la ligne de commande du Dos:
Sélectionner la rom bios et poker la valeur 2 en 0B13h (mode écran de démarrage), puis sélectionner la vitesse lente:

! ROM=256 :010B130002 CpuSlow
(ne pas oublier l'espace entre les commandes)

Si une commande n'est pas reconnue elle sera interprétée comme une commande Cpc, ainsi que le reste de la ligne. Il est ainsi possible d'ajouter une ou plusieurs commandes Cpc à la suite des commandes CpcAlive. (seulement à partir de l'interpréteur Dos.)

exemple

! ROM=256 :010B130002 CpuSlow PRINT"OK"

note:
- charger des données en ram dans les blocs 0,1,2 ou 3 avant l'initialisation du système Cpc est inutile puisque celle-ci est effacée au démarrage. Pour charger des données en ram avec des lignes intel hex à partir de la ligne de commande du Dos, il faut que le système ait été lancé puis mis en veille auparavant.


Fichiers de commandes CpcAlive

Ces fichiers sont destinés, comme leur nom l'indique, à commander l'émulateur à partir d'un fichier. Ce fichier doit commencer par la séquence "CDE:" ou "CMD:" sans les guillemets (entête).

Chargement d'un fichier de commandes à partir de la ligne de commande du Dos:
! FICHIER.CMD
Chargement d'un fichier de commandes à partir d'un autre fichier de commandes CpcAlive:
FICHIER.CMD
Chargement d'un fichier de commandes à partir de l'interpéteur basic du Cpc:
 |INPUT,"FICHIER.CMD"

exemple 1:

CMD:               ; entête fichier de commandes CpcAlive
ROM=256        ; sélection rom bios
:010B130002    ; poker la valeur 2 en 0B13h (mode écran de démarrage)
CommandEnd   ; ferme le fichier de commande

exemple 2:

CMD:                ; entête fichier de commandes CpcAlive
ROM=256        ; sélection rom bios
:010B130002    ; poker la valeur 2 en 0B13h (mode écran de démarrage)
KeyBoard        ; à partir d'ici chaque caractère est transmis au gestionnaire clavier du Cpc.
PRINT"OK"

exemple 3:

PRINT"OK1"
|COMMAND    ; à partir d'ici le fichier est interprété par l'interpréteur de commandes CpcAlive
ROM=256        ; sélection rom bios
:010B130002    ; poker la valeur 2 en 0B13h (mode écran de démarrage)
KeyBoard        ; à partir d'ici chaque caractère est transmis au gestionnaire clavier du Cpc.
PRINT"OK2"


Il est aussi possible de charger à partir d'un fichier de commandes CpcAlive les types de fichiers suivants: Disquettes virtuelles au format .DSK , Fichiers Roms Cpc , Fichiers au format intel hex , Fichiers de commandes Cpcalive , Documents textes et Fichiers binaires . L'imbrication des fichiers de commandes est autorisée dans la limites de 15 fichiers maximum (fichiers de textes compris). Un bon exemple est le fichier ROM.INI qui est un fichier de commande qui est destiné à l'initialisation de l'émulateur. C'est à partir de celui-ci que sont chargées par exemple les roms du Cpc. Noter la présence du séparateur ';' pour les commentaires. (Ne pas utiliser la commande KeyBoard dans le fichier ROM.INI). Le fichier de commandes CPC.INI situé dans le répertoire principal est un fichier utilisateur qui est exécuté à chaque lancement de l'émulateur et peut donc recevoir des commandes de configuration.



- 1e - Chargement de fichiers au format texte

Au cas ou le type de fichier n'est pas reconnu par CpcAlive comme étant un des fichiers détaillés plus haut, CpcAlive considère qu'il s'agit d'un fichier au format texte. CpcAlive traite ces fichiers de la maniére suivante: chaque caractère du document est lu, puis envoyé au gestionnaire clavier du système Cpc. Il est ainsi possible, par exemple, de transmettre par cette fonction un fichier basic au format texte ou commander un programme tournant dans l'émulateur.

Chargement à partir de la ligne de commande du Dos:
! EXEMPLE.BAS
Chargement à partir d'un fichier de commande CpcAlive:
EXEMPLE.BAS
Chargement à partir de l'interpéteur basic du Cpc:
 |INPUT,"EXEMPLE.BAS"

Ces commandes chargent le programme nommé exemple.bas s'il existe, à travers le gestionnaire clavier du Cpc. Dans cet exemple, le fichier "exemple.bas" est situé dans le répertoire CpcAlive.  Si le fichier n'existe pas, la chaîne "exemple.bas" sera transmise au gestionnaire clavier du Cpc, ce qui débouchera vraisemblablement sur un message "Syntax error".

exemple à partir de l'interpréteur basic:

mode 2
10 |Input,"FILE_ID.DIZ"
20 line input a$:if a$="" then |STOP:end else goto 20
run

Cet exemple charge le document "FILE_ID.DIZ" jusqu'à ce qu'il rencontre une ligne vide. La commande |STOP ferme le fichier.

L'imbrication des fichiers de textes est autorisée dans la limites de 15 fichiers maximum (fichiers de commandes compris).
Il est aussi possible de charger des textes dans l'émulateur CpcAlive à partir de la fonction copier/coller de Windows XP. Voir mode d'emploi.


- 1f - Chargement de fichiers binaires

 Il est possible de charger des données dans la mémoire du Cpc en utilisant le marqueur ":D" (comme 'D'atas) en utilisant la syntaxe suivante:

Depuis l'interpréteur Basic du Cpc:
|INPUT,"Nom_de_fichier:D,longueur_bloc,adresse_bloc_dans_fichier,adresse_de_chargement_dans_mémoire_cpc"
(penser à protéger le bloc chargé avec la commande: MEMORY adresse_de_chargement - 1)

Depuis un fichier de commandes CpcAlive:
Nom_de_fichier:D,longueur_bloc,adresse_bloc_dans_fichier,adresse_de_chargement_dans_mémoire_cpc

Il est ainsi possible de traiter tout type de fichier. L'exemple ci-dessous charge une image BMP (option de format OS/2, 16 couleurs, 180*100 maxi) et l'affiche sur l'écran Cpc.

10 memory &3FFF:adr=&4000
20 ximg=0:yimg=0:nameimg$="image.bmp":' <<<< X,Y,NOM IMAGE
30 |input,nameimg$+":D,&4100,0,&4000"
40 if peek(adr+&E)+256*peek(adr+&F)<>12 then mode 2:?"OS/2 format only accepted":end
50 x=peek(adr+&18)+256*peek(adr+&19)
60 if x<>4 then mode 2:?"16 colors in image only accepted.":end
70 mode 0:x=0:for i=0 to 45 step 3:|ink,x,peek(adr+&1C+i),peek(adr+&1B+i),peek(adr+&1A+i):x=x+1:next
80 largeur=peek(adr+&12)+256*peek(adr+&13)
90 hauteur=peek(adr+&14)+256*peek(adr+&15)
100 reste=largeur mod 2:x=int(largeur/2)+reste:while x mod 4 <> 0:x=x+1:wend:larbloc=x
110 adr=adr+peek(adr+&A)+256*peek(adr+&B):'adresse image dans fichier
120 for i=0 to hauteur*4 step 4:x=0
130 for j=adr to adr+(int(largeur/2)+reste)
140 pencil=(peek(j) and &F0)/16:plot ximg+x,yimg+i,pencil:plot ximg+x,yimg+i+2,pencil:x=x+4
150 pencil=peek(j) and &F:plot ximg+x,yimg+i,pencil:plot ximg+x,yimg+i+2,pencil:x=x+4
160 next j:adr=adr+larbloc:next i
run


L'utilisation du marqueur :D seul à la suite du nom de fichier indique à l'émulateur qu'il doit transmettre la valeur au format décimal de chaque octet du fichier précédent le marqueur, à travers le gestionnaire clavier du Cpc. Cette fonction a été développée pour permettre de traiter aisément les données d'un fichier à partir de l'interpréteur basic du Cpc.

Comme exemple, voici un petit programme dont la fonction est de lire quelques octets du fichier ROM.INI et de les afficher au format hexadécimal:

10 mode 2:window#0,1,80,2,25:window#1,1,80,1,1
20 |Input,"ROM.INI:D"
30 for i=0 to 100
40 input#1,a:Print hex$(a,2)" ";
50 next i
60 |STOP
run


 La  commande |GO,"chaine numérique"[,@er%] déplace le pointeur de fichier.
Dans ce cas, "chaine" représente la valeur du déplacement par rapport au début
du fichier.
Le paramètre de retour d'erreur @er% est faculatif. S'il est mis,
la signification des valeurs récupérées dans la variable er% sont:
0 = ok
1 = erreur
(Ne pas oublier d'initialiser er% au départ du programme ou avant la commande)

ex: |GO,"&100"

Déplace le pointeur de fichier à la position &100. La valeur maximale est &FFFFFFFF. Le pointeur de fichier peut-être aussi écrit en décimal.



- 2 - Commandes Cpc à partir de la ligne de commande du Dos
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Les commandes Cpc doivent toujours être placées en dernier dans la ligne de commande.

ex: ! PRINT"OK"
Lance l'émulateur et passe la commande PRINT"OK" au Cpc, à travers le gestionnaire clavier du Cpc.

Cas particulier:
Le caractère '|' (obtenu en actionnant en même temp la touche [ALT GR] et la touche [6] en haut du clavier) est une commande dos. CpcAlive utilise donc un caractère de substitution qui est le '§' situé juste à gauche de la touche [SHIFT DROITE].

ex: ! §DISC
Lance l'émulateur et passe la commande |DISC au Cpc.

Cette touche de substitution sera toujours utilisée dans CpcAlive en raison de sa facilité d'accès. Tu peux donc te servir de ce "raccourci clavier" à partir de la ligne de commande du basic du Cpc.

Il existe d'autres caractères réservés par Dos comme le '<' ou '>' qui ne pourront pas êtres utilisés comme commande Cpc à partir de la ligne de commande Dos. Pour plus d'information, lire la documentation du système Dos.


- 3 - Fichier de sortie
~~~~~~~~~~~~~~~~~~~~
Par défaut la sortie imprimante du Cpc se fait dans le fichier CPC.PRN situé dans le répertoire principal CpcAlive. Il est possible de changer le nom du fichier de sortie à partir de la ligne de commande Dos en ajoutant le caractère '>' à la fin de la ligne de lancement suivi du nom de fichier désiré.

exemple:
! PRINT#8,"OK" inscrit le mot "OK" dans le fichier Cpc.prn
! PRINT#8,"OK">test.prn inscrit le mot "OK" dans le fichier test.prn

Un seul caractère '>' avant le nom du fichier de sortie indique au Dos qu'au cas ou le nom du fichier de sortie existe déjà, ce fichier sera recrée vierge avant de recevoir les données. (L'ancien fichier de sortie du même nom étant effacé sans préavis... prudence). Deux caractères '>>' avant le fichier de sortie indique au Dos qu'il doit conserver le fichier et mettre les nouvelles données à suivre. (Il n'existe pas pour l'instant de commande équivalente à partir de l'interpréteur basic du Cpc)

exemple:
! PRINT#8,"OK1":§Exit>test.prn inscrit le mot "OK1" dans le fichier test.prn
! PRINT#8,"OK2":§Exit>>test.prn inscrit le mot "OK2" à suivre dans le fichier test.prn

Le résultat dans le fichier test.prn donne:
OK1
OK2

Il est possible de changer de nom de fichier de sortie à partir de l'interpréteur Basic du Cpc en tapant la commande suivante:  |OUTPUT,"NomDeFichier"[,@er%]

Le paramètre de retour d'erreur @er% est faculatif. S'il est mis, la signification des valeurs récupérées dans la variable er% sont:
0 = ok
1 = erreur dans les paramètres
3 = chemin non trouvé
4 = plus de handle disponible
5 = accès refusé
(Ne pas oublier d'initialiser er% au départ du programme ou avant la commande)

Un petit programme qui redirige la sortie CATalogue vers le fichier de sortie:

10 POKE &BB5C,PEEK(&BD2D):POKE &BB5B,PEEK(&BD2C)
20 CAT
30 CALL &BD37:|DISC
RUN

note: le fichier CPC.PRN est vidé à chaque lancement de l'émulateur.


III - Commandes à partir de l'interpréteur basic du CPC:

Les commandes CpcAlive appelables à partir de l'interpréteur basic doivent être précédées de la barre verticale " | ".

|CpuFast                    = instaure la vitesse maximum
|CpuSlow                   = instaure la vitesse normale (vitesse de l'ordinateur Cpc)
|Sleep                        = pour mettre en veille de l'émulateur         [AltGr][S]
 |Sleep,"message"        = mise en veille avec message
|Exit                          = pour quitter l'émulateur                        [Ctrl][Alt][Fin]
|Exit,"message"          = quitter l'émulateur avec message
|Command                 = passe du mode "clavier" au mode "commande CpcAlive"
                                    (voir chapitre II paragraphe - 1d -)
|INPUT,"nom_de_fichier[:X]"[,@er%]
                                = charge un fichier (voir chapitre II paragraphe - 1 -)
|STOP                      = voir chapitre II paragraphe - 1e -
|GO,"chaine numérique"[,@er%]
                               = déplace le pointeur de fichier_d_entrée (voir chapitre II paragraphe - 1f -)
|OUTPUT,"fichier_de_sortie"[,@er%]
                                = démarre un nouveau fichier_de_sortie (voir chapitre II paragraphe - 3 -)
|OUTASCDOS          = voir chapitre IV
|OUTASCWIN          = voir chapitre IV
|OUTASCOFF           = voir chapitre IV
|PRINT,"chaine"        = sort une chaine de caractères vers le fichier_de_sortie.
                                   Commande équivalente à la commande PRINT#8,"chaine";
|LPRINT,"chaine"     = sort une chaine de caractères vers le fichier_de_sortie suivi
                                   d'un retour à la ligne.
                                   Commande équivalente à la commande PRINT#8,"chaine"
|INK,PEN,R,V,B       = change la couleur d'un PEN. Les lettres R,V,B représentent les
                                   composantes Rouge,Vert et Bleu comprises entre 0 et 255.
                                   ex: |INK,0,0,255,0 (change couleur PAPER)
                                   ex: |INK,1,255,0,0 (change couleur PEN 1)
|INKRESTORE         = restore les encres originales (standards ou CpcAlive).
|INKCPC                  = instaure les encres standard du Cpc
|INKSOFT                = instaure les encres CpcAlive (encres par défaut)
                                   La palette est la même que la palette standard Cpc mais avec moins
                                   de luminosité, et les valeurs Paper et Pen 1 sont modifiées au
                                   démarrage.
|OBMP,"nom_de_fichier"[,@er%]
                                = fabrique un fichier image de l'écran Cpc au format BMP
                                   - voir commande |OUTPUT pour la signification des codes d'erreurs.
|DEBUG,adresse       = lance le débuggeur lorsque le processeur Z80 rencontre l'adresse spécifiée
|DEBUGOFF            = met fin au mode débuggeur
|DUMP,adresse         = initialise l'adresse de départ du dump mémoire du débuggeur
 CALL 0                    = réinitialise le système Cpc [CTRL][ALT][Home]



IV - CARACTèRES ACCENTUéS

La commande ! Accent.ini à partir de la ligne de commande Dos initialise le Cpc afin d'obtenir un clavier accentué. Le fichier Accent.ini se termine par la commande |sleep, il faudra donc relancer l'émulateur à partir du Dos à la suite de cette commande. Le fichier Accent.ini est un document texte composé de commandes basic facilement intégrables dans les programmes basics.

|OutAscDos et |OutAscWin à partir du Basic Cpc indiquent à l'émulateur qu'il doit convertir les caractères 192 à 204 (redéfinis dans le fichier ROM.INI) avant de les diriger vers le fichier de sortie. Pour opérer une conversion texte au format Dos vers le fichier de sortie, utiliser la commande |OutAscDos. Pour opérer une conversion texte au format Windows vers le fichier de sortie utiliser la commande |OutAscWin. Pour annuler cette conversion utiliser la commande |OutAscOff. Cette commande est utile si l'on utilise le fichier de sortie pour autre chose que du texte. (Commande par défaut)

Les caractères sont redéfinis de la façon suivante:
caractère:                ë     ù     û    ô