Section courante

A propos

Section administrative du site

 Langage  Elément  Tutoriel  Annexe  Aide 
ABAP/4
Ada
Assembleur
Assembly & bytecode
ASP (Active Server Pages)
Basic
C
C++
C# (C Sharp)
Cobol
ColdFusion
Fortran
HTML
Java
JavaScript
LISP
Logo
LotusScript
Oberon
Pascal
Perl
PHP
PL/1
Prolog
Python
Rebol
REXX
Ruby
SAS
NoSQL
SQL
Swift
X++ (Axapta)
GNAT
SMALLAda
VHDL
Assembleur 370
Assembleur 1802
Assembleur 4004
Assembleur 6502
Assembleur 6800
Assembleur 68000
Assembleur 8080 et 8085
Assembleur 8089
Assembleur 80x86
Assembleur AGC4
Assembleur ARM
Assembleur DPS 8000
Assembleur i860
Assembleur Itanium
Assembleur MIPS
Assembleur PDP-11
Assembleur PowerPC
Assembleur RISC-V
Assembleur SPARC
Assembleur SuperH
Assembleur UNIVAC I
Assembleur VAX
Assembleur Z80
Assembleur Z8000
Assembleur z/Architecture
ASSEMBLER/MONITOR 64
Micol Assembler
GFA Assembler
A86
MASM (Macro Assembler)
TASM (Turbo Assembler)
CIL
Jasmin
LLVM
MSIL
Parrot
P-Code (PCode)
SWEET16
G-Pascal
ASP 1.0
ASP 2.0
ASP 3.0
ASP.NET
ASP.NET Core
ABasiC (Amiga)
Adam SmartBASIC
Altair BASIC
AmigaBASIC (Amiga)
AMOS Basic (Amiga)
Atari Basic (Atari 400, 600 XL, 800, 800XL)
Basic Apple II (Integer BASIC/APPLESOFT)
Basic Commodore 64 (CBM-BASIC)
Basic Commodore 128 (BASIC 7.0)
Basic Commodore VIC-20 (CBM-BASIC 2.0)
Basic Coco 1 (Color Basic)
Basic Coco 2 (Extended Color Basic)
Basic Coco 3 (Extended Color Basic 2.0)
BASICA (PC DOS)
Basic Pro
BBC BASIC
Blitz BASIC (Amiga)
DarkBASIC
Dartmouth BASIC
GFA-Basic (Atari ST/Amiga)
GWBASIC (MS-DOS)
Liberty BASIC
Locomotive BASIC (Amstrad CPC)
MSX-Basic
Omikron Basic (Atari ST)
Oric Extended Basic
Power Basic
Quick Basic/QBasic (MS-DOS)
Sinclair BASIC (ZX80, ZX81, ZX Spectrum)
ST BASIC (Atari ST)
Turbo Basic
Vintage BASIC
VBScript
Visual Basic (VB)
Visual Basic .NET (VB .NET)
Visual Basic pour DOS
Yabasic
BeckerBASIC
SIMONS' BASIC
Basic09 d'OS-9
Disk Extended Color Basic
Basic09 d'OS-9
Disk Extended Color Basic
Access
Excel
Visual Basic pour Windows
Visual Basic .NET pour Windows
C Shell Unix (csh)
C pour Amiga
C pour Atari ST
C pour DOS
C pour Falcon030
C pour GEMDOS (Atari ST)
C pour Linux
C pour PowerTV OS
C pour OS/2
C pour Unix
C pour Windows
Aztec C
CoCo-C
GNU C
HiSoft C
IBM C/2
Introl-C
Lattice C
Microsoft C
MinGW C
MSX-C
Open Watcom C
OS-9 C Compiler
Pure C
Quick C
Turbo C
HiSoft C for Atari ST
HiSoft C for CP/M (Amstrad CPC)
C++ pour OS/2
C++ pour Windows
Borland C++
C++Builder
IBM VisualAge C++
Intel C++
MinGW C++
Open Watcom C++
Symantec C++
Turbo C++
Visual C++
Visual C++ .NET
Watcom C++
Zortech C++
C# (C Sharp) pour Windows
Apple III Cobol
Microsoft Cobol
BlueDragon
Lucee
OpenBD
Railo
Smith Project
Microsoft Fortran
WATFOR-77
CSS
FBML
Open Graph
SVG
XML
XSL/XSLT
LESS
SASS
GCJ (GNU)
JSP
Jython
Visual J++
Node.js
TypeScript
AutoLISP
ACSLogo
LotusScript pour Windows
Amiga Oberon
Oberon .NET
Apple Pascal
Delphi/Kylix/Lazarus
Free Pascal
GNU Pascal
HighSpeed Pascal
IBM Personal Computer Pascal
Lisa Pascal
Maxon Pascal
MPW Pascal
OS-9 Pascal
OSS Personal Pascal
Pascal-86
Pascal du Cray Research
Pascal/VS
Pascal-XT
PURE Pascal
QuickPascal
RemObjets Chrome
Sun Pascal
THINK Pascal
Tiny Pascal (TRS-80)
Turbo Pascal
UCSD Pascal
VAX Pascal
Virtual Pascal
Turbo Pascal for CP/M-80
Turbo Pascal for DOS
Turbo Pascal for Macintosh
Turbo Pascal for Windows
CodeIgniter (Cadre d'application)
Drupal (Projet)
Joomla! (Projet)
Phalanger (PHP .NET)
phpBB (Projet)
Smarty (balise)
Twig (balise)
Symfony (Cadre d'application)
WordPress (Projet)
Zend (Cadre d'application)
PL360
PL/M-80
PL/M-86
Turbo Prolog
CPython
IronPython
Jython
PyPy
AREXX
Regina REXX
JMP
Btrieve
Cassandra
Clipper
CouchDB
dBASE
Hbase
Hypertable
MongoDB
Redis
Access
BigQuery
DB2
H2
Interbase
MySQL
Oracle
PostgreSQL
SAP HANA
SQL Server
Sybase
U-SQL
Introduction
Référence de commandes et fonctions
Les premiers pas
Les fondements d'Altair BASIC
L'Extended BASIC
Comment est charger BASIC 4K et 8K
Comment est chargé Extended BASIC
Boîte de dialogue d'initialisation
Conseils d'espace
Conseils de vitesse
Fonctions mathématiques simulées
Conversion de programmes de base non écrits pour l'Altair BASIC
Utilisation de l'interface ACR
Référence des codes d'erreurs
Fonctions dérivées
Codes de caractères ASCII
Préface
Notes légal
Dictionnaire
Recherche

Les premiers pas

Avant qu'un ordinateur puisse exécuter une fonction utile, il faut lui «dire» ce qu'il doit faire. Malheureusement, les ordinateurs ne sont pas capables de comprendre l'anglais ou toute autre langue "humaine". C'est d'abord parce que nos langues sont riches d'ambiguïtés et de sous-entendus. L'ordinateur doit recevoir des instructions précises et la séquence exacte des opérations à effectuer pour accomplir une tâche spécifique. Par conséquent, afin de faciliter la communication humaine avec un ordinateur, des langages de programmation ont été développés.

L'Altair BASIC est un langage de programmation à la fois facile à comprendre et simple à utiliser. C'est un excellent "plus" pour des applications dans des domaines tels que les affaires, la science et l'éducation. Avec seulement quelques heures d'utilisation de BASIC, vous constaterez que vous pouvez déjà écrire des programmes avec une facilité que peu d'autres langages informatiques peuvent reproduire.

Développé à l'origine à l'Université de Dartmouth, le langage BASIC a trouvé une large acceptation dans le domaine informatique. Bien qu'il soit l'un des langages informatiques les plus simples à utiliser, il est très puissant. Le BASIC utilise un petit ensemble de mots anglais courants comme ses "commandes". Conçu spécifiquement comme un langage "interactif", vous pouvez donner une commande telle que "PRINT 2 + 2", et Altair BASIC répondra immédiatement par "4". Il n'est pas nécessaire de soumettre un jeu de cartes avec votre programme dessus et d'attendre des heures pour les résultats. Au lieu de cela, toute la puissance de l'Altair est "à portée de main".

Généralement, si l'ordinateur ne résout pas un problème particulier comme vous l'espériez, il y a un "Bogue" ou une erreur dans votre programme, ou bien il y a une erreur dans les données que le programme a utilisées pour calculer sa réponse.

LAltair 680 BASIC est identique à Altair 8800 8K BASIC, révision 3.2, à quelques exceptions près.

Chargement de l'Altair 680 BASIC

L'Altair BASIC est chargé dans le 680 à l'aide de la commande L du PROM Monitor.

Boîte de dialogue d'initialisation

Démarrage de BASIC : Utilisez la commande J du moniteur PROM pour commencer l'exécution de BASIC à l'adresse 0 :

.J 0000

Après avoir démarré BASIC, il répondra :

MEMORY SIZE?

Si vous tapez un retour de chariot à MEMORY SIZE?, le BASIC utilisera toute la mémoire contiguë vers le haut à partir de l'emplacement zéro qu'il peut trouver. BASIC arrêtera la recherche lorsqu'il trouvera un octet de ROM ou de mémoire inexistante.

Si vous souhaitez n'allouer qu'une partie de la mémoire de l'Altair au BASIC, tapez le nombre d'octets de mémoire que vous souhaitez allouer en décimal.

Cela pourrait être fait, par exemple, si vous utilisiez une partie de la mémoire pour un sous-programme en langage machine.

BASIC demandera alors :

TERMINAL WIDTH?

Il s'agit de définir la largeur de ligne de sortie pour les instructions PRINT uniquement. Tapez le nombre de caractères pour la largeur de ligne pour le terminal particulier ou autre périphérique de sortie que vous utilisez. Il peut s'agir de n'importe quel nombre compris entre 1 et 255, selon le terminal. Si aucune réponse n'est donnée (c'est-à-dire qu'un retour chariot est tapé), la largeur de ligne est définie sur 72 caractères.

Maintenant, Altair BASIC entrera dans une boîte de dialogue vous permettant de supprimer certaines des fonctions arithmétiques. La suppression de ces fonctions donnera plus d'espace mémoire pour entreposer vos programmes et variables. Cependant, vous ne pourrez pas appeler les fonctions que vous supprimez. Toute tentative de le faire entraînera une erreur FC. La seule façon de restaurer une fonction ayant été supprimée est de recharger BASIC.

Voici la boîte de dialogue apparaissant :

WANT SIN-COS-TAN-ATN?

Répondez "Y" pour conserver les quatre fonctions, "N" pour supprimer les quatre ou "A" pour supprimer ATN uniquement.

BASIC va maintenant taper :

        XXXX BYTES FREE
    MITS ALTAIR 680 BASIC
    VERSION Y.Y REV Z.Z
COPYRIGHT, 1976 BY MITS, INC.

"XXXX" est le nombre d'octets disponibles pour le programme, les variables, l'entreposage de la matrice et la pile. Il n'inclut pas l'espace de chaîne de caractères. Y.Y est le numéro de version. Z.Z est le numéro de révision.

OK

INP et OUT

Les fonctions INP et OUT de l'Altair 8800 BASIC ne sont pas nécessaires dans le 680 BASIC en raison de la structure d'entrée/sortie du microprocesseur 6800. Le 6800 gère les entrées/sorties en adressant certains emplacements de mémoire en tant que ports. Par conséquent, pour effectuer une entrée, la fonction PEEK est utilisée. Par exemple, supposons que l'emplacement mémoire 6500010 soit un port d'entrée pour un périphérique. Ensuite pour obtenir les informations, il suffit d'utiliser :

  1. I=PEEK(65000)

en commande directe ou indirecte.

Pour la sortie, utilisez la commande POKE. Pour envoyer un "A" ASCII au port adressé par 6400010, utilisez l'instruction :

  1. POKE 64000, ASC("A")

en commande directe ou indirecte.

Interface utilisateur en langage machine

Un utilisateur peut appeler sa propre fonction de langage machine en utilisant la fonction USR. L'utilisateur doit réserver de la mémoire pour cette fonction en tapant un nombre en réponse à la question d'initialisation de BASIC :

MEMORY SIZE?

Par exemple, pour réserver 1 Ko de mémoire pour les fonctions utilisateur dans une machine de 17 Ko, la réponse serait :

16383

La fonction utilisateur peut être chargée en mémoire via le PROM Monitor. Les commutateurs du panneau avant ou la fonction POKE en BASIC. Avant d'appeler la fonction utilisateur, l'adresse de début de la fonction doit être entreposée aux emplacements 287(10) (octet de poids fort de l'adresse) et 288(10) (octet de poids faible de l'adresse). Par exemple, si la fonction utilisateur commence à 17 Ko, la procédure suivante doit être utilisée.

17 Ko est 4000(16)
donc 40(16) doit être entreposé dans 287(10)
et 00(16) doivent être entreposés dans 288(10)
40(16) est 4 x 16 = 64(10)
et 0 vaut 0 dans n'importe quelle base

donc les commandes :

  1. POKE 287, 64

and :

  1. POKE 288, 21

serait utilisé pour entreposer l'adresse de départ de la fonction utilisateur. L'appel à une fonction utilisateur est :

  1. Y = USR(X)

X est le paramètre et doit être un nombre compris entre +32767(10) et -32768(10). Le résultat de la fonction USR est renvoyé dans Y et doit également être compris entre +32767(10) et -32768(10).

Le paramètre est obtenu pour être utilisé dans la fonction utilisateur en appelant la routine dont l'adresse est donnée aux emplacements 0115 et 0116 (hexadécimal). Par conséquent, les instructions :

  1. LDX $3115
  2. JSR X

provoquer la conversion du paramètre en un entier signé de deux octets avec l'octet de poids fort entreposé à l'emplacement 174(10) et l'octet de poids faible entreposé à 175(10).

Le résultat de la fonction est renvoyé au BASIC en entreposant l'octet de poids fort dans l'accumulateur A, l'octet de poids faible dans l'accumulateur B et en appelant la routine dont l'adresse est donnée aux emplacements 0117 et 0118 (hexadécimal).

Par exemple, les instructions :

  1. CLR A
  2. LDA 8 #3
  3. LDX $0117
  4. JSR X

renverra une valeur de 3 à BASIC. Le contrôle du programme est rendu au BASIC en exécutant une instruction RTS.

Exemple de fonction USR

La fonction USR décrite ci-dessous génère un retard de programme de 1 seconde fois le paramètre. La fonction suppose que le paramètre est compris entre 1 et 255(10). La valeur renvoyée au BASIC est toujours zéro. On suppose que l'utilisateur a répondu à la question sur la taille de la mémoire avec 16383 :

  1. 00001                     NAM USRFN
  2. 00002 4000                ORG $4000
  3. 00003 4000 FE 0115        LDX $0115  ; OBTENIR L'OCTET BAS DU PARAMETRE
  4. 00004 4003 AD 00          JSR X      ; INT0 B
  5. 00005 4005 D6 AF          LDA B 175  ; NOUS SUPPOSONS QUE L'OCTET HAUT EST 0
  6. 00006 4007 CE F424 WAIT1  LDX #62500; CETTE BOUCLE GENERE
  7. 00007 400A 09      WAIT2  DEX        ; UN RETARD DE PARAMETRE*1 SEC
  8. 00008 4008 26 FD          BNE WAIT2
  9. 00009 400D 5A             DEC B      ; DECREMENTATION DU PARAMETRE
  10. 00010 400E 26 F7          BNE WAIT1
  11. 00011 4010 4F             CLR A
  12. 00012 4011 FE 0117        LDX $0117  ; A et 8 SONT A ZERO
  13. 00013                                ; RETOURNER LA VALEUR A BASIC
  14. 00014 4014 6E 00          JMP X      ; JSR ET RTS
  15. 00015                     END

Remarque : Cette fonction a été développée à l'aide du système de développement de langage d'assemblage Altair 680.

Le programme BASIC suivant fait sonner la cloche du téléscripteur toutes les 10 secondes en appelant la fonction USR ci-dessus.

  1. 5 REM CONFIGURER L'ADRESSE USR
  2. 10 POKE 287,64
  3. 20 POKE 288,0
  4. 25 REM SONNE LA CLOCHE
  5. 30 PRINT CHR$(7);
  6. 35 REM RETARD 10 SECONDES
  7. 40 X=USR(10)
  8. 45 REM REFAITE-LE
  9. 50 GOTO 30 

Points de raccordement d'entrée/sortie du 680 BASIC

L'Altair 680 BASIC appelle des routines dans le moniteur 680 PROM pour effectuer des transferts d'entrée/sortie. Les routines suivantes sont nécessaires et l'adresse de leurs appels est donnée :

Routine Description
INCH Routine de caractères d'entrée. Lit le caractère du terminal, supprime la parité et renvoie le caractère ASCII 7 bits résultant dans l'accumulateur B. Appelé depuis l'emplacement 041F (hexadécimal).
OUTCH Routine de caractères de sortie. Envoie le caractère ASCII dans l'accumulateur B au terminal. Appelé depuis l'emplacement 08AD (hexadécimal).
POLCAT Sondage pour la routine de caractère. Vérifie l'état d'entrée du terminal. Renvoie l'ensemble de report si le caractère a été tapé. Les retours portent clair si aucun caractère n'a été tapé. Appelé depuis l'emplacement 0618 (hexadécimal).

Contrôle Baudot - C

La version Baudot du moniteur PROM ne prend en charge que les télétypes Baudot câblés pour un fonctionnement semi-duplex. Il est donc impossible de taper un Control+C pendant que BASIC fait une sortie. Par conséquent, BASIC vérifie le bit Baudot à l'emplacement F002 et s'il indique la présence d'un terminal Baudot, tout caractère tapé pendant que BASIC exécute un programme sera interprété comme un Control+C.



PARTAGER CETTE PAGE SUR
Dernière mise à jour : Mercredi, le 29 mars 2023