terug.gif
#include <dos.h>
#include <dir.h>
#include <stdio.h>
#include <windows.h>
#include <string.h>
#include <conio.h>
#include <sys\stat.h>
#include <fcntl.h>
#include <io.h>
#include "routines.h"
#include "datom.h"
extern unsigned char adres_b000;
extern unsigned char capsstatus;
extern unsigned char bEnd;
extern unsigned char bCursor;
extern unsigned char scale_x, scale_y;
extern unsigned char msb;
extern unsigned char joystat;
extern unsigned char venster_xlo; // coordinaten tekstvenster
extern unsigned char venster_ylo; //
extern unsigned char venster_xrb; //
extern unsigned char venster_yrb; //
extern unsigned int gwindow_xlo; // coordinaten grafisch venster
extern unsigned int gwindow_ylo; //
extern unsigned int gwindow_xrb; //
extern unsigned int gwindow_yrb; //
extern unsigned char kleur;
extern unsigned int rvenster_xrb;
extern unsigned int iobase;
extern unsigned char	regels;
extern BYTE bscan, bascii;
extern BOOL bShift, bCaps, bCtrl;
extern BOOL bKey;
extern BOOL bClear0, bGraph;
extern int rb_xco, rb_yco, nJoyb;
char szFilename[30];
extern BOOL		bPrinterstatus;
extern FILE		*prnfile;
extern char		schermpag;
extern BYTE		resettype;
unsigned char buf[256];
unsigned char buffer[256];
unsigned char keytab [] = {
0x00,0x71,0x2C,0x51,0x44,0x45,0x46,0x47,0x40,0x10,0x17,0x16,0x15,
0x14,0x13,0x2B,0x4A,0x4B,0x4C,0x4D,0x4E,0x4F,0x48,0x18,0x1F,0x1E,
0x1D,0x1C,0x23,0x43,0x53,0x54,0x55,0x56,0x39,0x50,0x20,0x27,0x26,
0x25,0x24,0x3C,0x00,0x1B,0x73,0x74,0x75,0x76,0x77,0x70,0x28,0x2F,
0x2E,0x2D,0x00,0x06,0x00,0x37,0x00,0x3D,0x3E,0x3F,0x38,0x0E,0x0D,
0x0C,0x0B,0x08,0x0F,0x00,0x00,0x09,0x2A,0x21,0x04,0x33,0x00,0x31,
0x07,0x0A,0x32,0x29,0x1A,0x19,0x00,0x00,0x00,0x67,0x68,0x69,0x04,
0x64,0x65,0x66,0x07,0x61,0x62,0x63,0x60,0x6A
};
unsigned char kbmatrix [] = {
0x99,0x05,0x21,0x11,0x01,0x92,0x82,0x72,0x62,0x52,
0x42,0x31,0x02,0x32,0x41,0x51,0x04,0x45,0x23,0x95,
0x75,0x25,0x65,0x84,0x24,0x14,0x80,0x60,0x61,0x99,
0x63,0x85,0x33,0x13,0x03,0x94,0x74,0x64,0x54,0x22,
0x73,0x50,0x99,0x70,0x15,0x35,0x43,0x55,0x53,0x34,
0x44,0x12,0x93,0x83,0x99,0x99,0x99,0x90,0x40
	 };
unsigned char setkey [] ={0xFE,0xFD,0xFB,0xF7,0xEF,0xDF,0xBF,0x7F };
unsigned char resetkey [] ={0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80 };
unsigned char keymatrix [16];
extern int xco, yco;
extern char scherm[50][99];
void drukaf()
/*
#00 Druk $0 af
Invoer: geen
Uitvoer: geen
*/
{
}
void keyb()
/*
#01 Keyboard scan
	 Invoer: geen
Uitvoer: scan code (1 byte)
keyboard status (1 byte)
De scan codes zijn niet gelijk aan de standaard PC-
scancodes. Deze codes worden door de Atom als index
gebruikt om de bijbehorende ascii waarde te bepalen uit
een tabel.
Als u gebruik wil maken van keyboard codes wordt commando
#3A aanbevolen; daarmee zijn ook functietoetsen uit te
lezen.
De keyboard status bits hebben de volgende betekenis:
pccom01.gif
Door de Atom wordt de TAB toets gebruikt als COPY toets. */ { unsigned char toets=0, status = 0; if (bShift) status |= 0x80; if (bCtrl) status |= 0x40; if (bKey == TRUE) { if (bscan < 0x46) { toets = keytab[bscan]; status |= 0x01; } bKey = FALSE; } WRITEBYTE(iobase, toets); WRITEBYTE(iobase, status); } void copy() /* #02 Lees karakter op cursorpositie Invoer: geen Uitvoer: ascii waarde van teken op cursorpositie Wordt o.a. gebruikt bij afhandeling van copy toets. */ { char tekst[40]; WRITEBYTE(iobase, (char) scherm[yco][xco]); } void gplot() /* #03 Plot pixel Invoer: X-coördinaat (1 word) Y-coördinaat (1 word) Plot mode (1 byte) Uitvoer: geen De coördinaten zijn afhankelijk van de grafische resolutie van de videokaart. Voor Hercules is dat 720*348 en voor CGA is dat 640*200. Dit commando voert een bewerking uit met het opgegeven pixel. Deze bewerkingen zijn: mode = 1 -> zet pixel mode = 2 -> inverteer pixel mode = 3 -> wis pixel */ { unsigned int x,y; unsigned int plot; unsigned int result; result = READBYTEW(iobase); // low value x = result & 255; result = READBYTEW(iobase); // high value x = x + (256 * result); result = READBYTEW(iobase); // low value y = result & 255; result = READBYTEW(iobase); // high value y = y + (256 * result); result = READBYTEW(iobase); plot = result & 255; pixel(x, y, plot); } void igraph() /* #04 Initialiseer grafische mode Invoer: geen Uitvoer: geen Dit commando schakelt de videokaart om naar de grafische mode. Voor EGA/VGA kaarten wordt de CGA mode ingeschakeld met een resolutie van 640*200. */ { // Binnen windows heeft deze functie geen betekenis bGraph = TRUE; // settimers(hWnd); wClear(); } void simulate4() /* #05 Plot pixel in clear 4 coördinatenstelsel Invoer: X-coördinaat (1 word) Y-coördinaat (1 word) Plot mode (1 byte) Uitvoer: geen De coördinaten zijn in dit geval gelijk aan de grafische resolutie van de Atom (256*192). Verder is dit commando hetzelfde als #03. mode = 1 -> zet pixel mode = 2 -> inverteer pixel mode = 3 -> wis pixel */ { unsigned int x,y; unsigned int plot; unsigned int result; result = READBYTEW(iobase); // low value x = result & 255; result = READBYTEW(iobase); // high value x = x + (256 * result); result = READBYTEW(iobase); // low value y = result & 255; result = READBYTEW(iobase); // high value y = y + (256 * result); result = READBYTEW(iobase); plot = result & 255; if (y < 192 && x < 256) { pixel(x, y, plot); } } void ramfnt() /* #06 Ramfont laden Invoer: filenaam van het ramfont als ASCIIZ string Uitvoer: errorcode De naam van het te laden font wordt als ascii string overgestuurd. Deze string eindigt met de code #00. De filenaam mag een kompleet pad bevatten maar geen wildcards (* of ?). Als het font geladen is, is de errorcode #00. Als een fout opgetreden is (bijv. font niet gevonden) dan duidt de uitvoer de aard van de fout aan. */ { unsigned char dummy; int i; do { dummy = READBYTEW(iobase); } while (dummy !=0); // Binnen windows heeft deze functie geen betekenis } int schrijf() /* #07 Schrijf string in grafische mode Invoer: X-coördinaat (1 word) Y-coördinaat (1 word) ASCIIZ string Uitvoer: geen De opgegeven string wordt geplot vanaf de coördinaten X en Y. */ { char szTekst[80]; int i=0; int x, y; unsigned int result; result = READBYTEW(iobase); // low value x = result & 255; result = READBYTEW(iobase); // high value x = x + (256 * result); result = READBYTEW(iobase); // low value y = result & 255; result = READBYTEW(iobase); // high value y = y + (256 * result); do { szTekst[i] = READBYTEW(iobase); } while (szTekst[i++] !=0); // de handel nog even via de plot vector wegsturen return TRUE; } void schaal() /* #08 Zet horizontale en vertikale schaalfactor Invoer: horizontale schaalfactor (1 byte) vertikale schaalfactor (1 byte) Uitvoer: geen De horizontale en vertikale schaalfactoren bepalen de afmetingen van de karakters die met commando #07 worden afgedrukt. */ { scale_x = READBYTEW(iobase); scale_x = READBYTEW(iobase); } void cursor_on() /* #09 Zet cursor aan Invoer: geen Uitvoer: geen De cursor verschijnt als knipperend streepje op het scherm. */ { bCursor = TRUE; } void cursor_off() /* #0A Zet cursor uit Invoer: geen Uitvoer: geen De cursor verdwijnt van het scherm. */ { bCursor = FALSE; } int loadfile() /* #0B File van disk laden Invoer: filenaam als ASCIIZ string Uitvoer: errorcode, bloklengte(n) en data Als de PC de filenaam ontvangen heeft wordt de file geopend. Als dit lukt wordt de errorcode #00 (geen error) teruggestuurd. Vervolgens wordt een datablok van max. 255 bytes gelezen. De lengte van dit datablok wordt naar de Atom gestuurd, direct gevolgd door de data. Als het einde van de file bereikt is dan ontvangt de Atom een filelengte van #00. */ { FILE *input; int i, aantal; leesnaam(); if ((input = fopen(szFilename, "rb+")) == NULL) { WRITEBYTE(iobase, 1); // zeg dat de file *niet* geopend is return FALSE; } WRITEBYTE(iobase, 0); // zeg dat de file geopend is do { /* read the data and display it */ aantal = fread(buf, sizeof(char), 255, input); WRITEBYTE(iobase, aantal); for (i=0; i<aantal; i++) { WRITEBYTE(iobase, buf[i]); } } while (aantal == 255); WRITEBYTE(iobase, 0); // klaar is leen fclose(input); return TRUE; } int savefile() /* #0C File naar disk schrijven Invoer: filenaam als ASCIIZ string bloklengte(n) data Uitvoer: errorcode De PC leest de filenaam en probeert de file te openen. Als de file reeds bestond dan wordt deze overschreven (zonder vermelding). Als de file nog niet bestond dan wordt deze aangemaakt. Als de file geopend is wordt het resultaat overgestuurd naar de Atom; errorcode #00 geeft aan dat er geen fout opgetreden is. Daarna begint de data-overdracht. Eerst geeft de Atom de bloklengte, direct gevolgd door data. Als een blok overgestuurd is van Atom naar PC en het blok is naar disk geschreven dan meldt de PC het aantal geschreven bytes naar de Atom. Als dit niet gelijk is aan de bloklengte dan is de disk vol. Als de PC een bloklengte #00 ontvangt wordt de file gesloten. */ { FILE *output; int i, aantal, result; leesnaam(); if ((output = fopen(szFilename, "wb+")) == NULL) { WRITEBYTE(iobase, 1); // zeg dat de file *niet* geopend is return FALSE; } WRITEBYTE(iobase, 0); // zeg dat de file geopend is while ((aantal = READBYTEW(iobase)) !=0) { // lees de bloklengte for (i=0; i<aantal; i++) { result=READBYTEW(iobase); result &= 255; buf[i]=result; } fwrite(buf, sizeof(char), aantal, output); WRITEBYTE(iobase, aantal); } fclose(output); return TRUE; } void cat() /* #0D Disk catalog op scherm afbeelden Invoer: zoekpad/filespec als ASCIIZ string Uitvoer: geen De PC leest de filespecificatie, deze mag een drive, directory en een file-aanduiding met wildcards bevatten, en drukt deze op het scherm af. De uitvoer wordt door de PC direct op het scherm gezet en komt niet ter beschikking van de Atom. Een lege string wordt behandeld als *.* Hidden files worden niet op het scherm weergegeven. */ { struct ffblk ffblk; int done, i, count=0; char tekst[80]; leesnaam(); if (strlen(szFilename) == 0) strcpy(szFilename, "*.*"); done = findfirst(szFilename, &ffblk, 0); Process(CTRL_M); // genereeer een linefeed/cr while (!done) { sprintf(tekst, "%s", ffblk.ff_name); for (i=0; i<strlen(tekst); i++) { Process(tekst[i]); } for (;i<13; i++) { Process(0x20); } count += 13; if (count+13 > rvenster_xrb) { Process(CTRL_M); // genereer een linefeed/cr Process(CTRL_J); // genereer een linefeed/cr count = 0; } done = findnext(&ffblk); } // WRITEBYTE(iobase, 0); } int adir() /* Hulpfunctie voor het ophalen van de directory */ { leesnaam(); if (strlen(szFilename) != 0) { if (szFilename[1] == ':') { return szFilename[1] - 'A'; } } return 0; } void achdir() /* #0E Veranderen/opvragen van huidige directory Invoer: nieuwe directory als ASCIIZ string Uitvoer: foutcode huidige directory als ASCIIZ string Dit commando verandert van directory naar de opgegeven directory. Als er geen fout opgetreden is, wordt de foutcode #00, gevolgd door de actuele directory als ASCIIZ string naar de Atom gestuurd. Als de foutcode niet #00 is, dan volgt er geen ASCIIZ string. */ { int i; // if (adir() == 0) { leesnaam(); if (strlen(szFilename) != 0) { if (chdir(szFilename) == 0) { WRITEBYTE(iobase, 0); WRITEBYTE(iobase, szFilename[0]-'A'); for (i=1; i<strlen(szFilename); i++) WRITEBYTE(iobase, szFilename[i]); WRITEBYTE(iobase, 0); return; } } WRITEBYTE(iobase, 255); } void armdir() /* #0F Verwijder directory Invoer: te verwijderen directory als ASCIIZ string Uitvoer: foutcode lege ASCIIZ string De opgegeven directory wordt indien mogelijk van de disk verwijderd. Als dat gelukt is dan volgt nogmaals een #00 byte na de foutcode. Als de foutcode niet #00 is, dan volgt er geen ASCIIZ string. */ { int i; leesnaam(); if (strlen(szFilename) != 0) { if (rmdir(szFilename) == 0) { WRITEBYTE(iobase, 0); return; } } WRITEBYTE(iobase, 255); } void amkdir() /* #10 Maak directory aan Invoer: aan te maken directory als ASCIIZ string Uitvoer: foutcode lege ASCIIZ string De opgegeven directory wordt indien mogelijk op de disk aangemaakt. Als dat gelukt is dan volgt nogmaals een #00 byte na de foutcode. Als de foutcode niet #00 is, dan volgt er geen ASCIIZ string. */ { int i; leesnaam(); if (strlen(szFilename) != 0) { if (mkdir(szFilename) == 0) { WRITEBYTE(iobase, 0); return; } } WRITEBYTE(iobase, 255); } void delete() /* #11 Verwijder file van disk Invoer: filespec als ASCIIZ string Uitvoer: foutcode Deze functie verwijdert de opgegeven files van disk, mits deze niet Read-Only en/of Hidden zijn. Als er geen files gewist kunnen worden dan is de foutcode niet gelijk aan #00. Als er één of meerdere files gewist zijn, dan is de foutcode #00. De filespecificatie mag geen drive en directory bevatten, eventueel wel wildcards. */ { struct find_t ffblk; int done; int rc = 1; leesnaam(); done = _dos_findfirst(szFilename, _A_NORMAL, &ffblk); Process(CTRL_M); // genereeer een linefeed/cr while (!done) { rc = 0; unlink(ffblk.name); done = _dos_findnext(&ffblk); } WRITEBYTE(iobase, rc); } void alock() /* #12 Lock files Invoer: filespec als ASCIIZ string Uitvoer: foutcode Deze functie zet van de opgegeven files het Read-Only bit. Als er geen files gelocked kunnen worden dan is de foutcode niet gelijk aan #00. Als er één of meerdere files gelocked zijn, dan is de foutcode #00. De filespecificatie mag bestaan uit een drive, directory en wildcards. */ { struct find_t ffblk; int done; int rc = 1; leesnaam(); done = _dos_findfirst(szFilename, _A_NORMAL, &ffblk); Process(CTRL_M); // genereeer een linefeed/cr while (!done) { rc = 0; // lock(ffblk.name); done = _dos_findnext(&ffblk); } WRITEBYTE(iobase, rc); } void aunlock() /* #13 Unlock files Invoer: filespec als ASCIIZ string Uitvoer: foutcode Deze functie reset van de opgegeven files het Read-Only bit. Als er geen files geunlocked kunnen worden dan is de foutcode niet gelijk aan #00. Als er één of meerdere files geunlocked zijn, dan is de foutcode #00. De filespecificatie mag bestaan uit een drive, directory en wildcards. */ { struct find_t ffblk; int done; int rc = 1; leesnaam(); done = _dos_findfirst(szFilename, _A_NORMAL, &ffblk); Process(CTRL_M); // genereeer een linefeed/cr while (!done) { rc = 0; // unlock(ffblk.name); done = _dos_findnext(&ffblk); } WRITEBYTE(iobase, rc); } void adrive() /* #14 Verander actuele drive Invoer: drive nummer (1 byte) Uitvoer: geen Met dit commando kan de actuele drive gewijzigd worden. Voor drive A: is het drivenummer 0, drive B: is drive nummer 1 etc. Er is geen terugmelding en controle op geldigheid van het drive nummer. */ { int result; result = READBYTEW(iobase); setdisk('A' + result); } void msdos() /* #15 Ga naar MS-DOS Invoer: geen Uitvoer: geen Dit commando be‰indigt het Atom terminal programma op de PC en de besturing wordt teruggegeven aan het oproepende programma. Voordat dit commando wordt uitgevoerd dienen geopende bestanden eerst gesloten te worden. */ { bEnd = TRUE; } void hide() /* #16 Maak file verborgen Invoer: filespec als ASCIIZ string Uitvoer: foutcode Deze functie zet van de opgegeven files het Hidden bit. Als er geen files verborgen kunnen worden dan is de foutcode niet gelijk aan #00. Als er één of meerdere files verborgen zijn, dan is de foutcode #00. De filespecificatie mag bestaan uit een drive, directory en wildcards. */ { struct find_t ffblk; int done; int rc = 1; leesnaam(); done = _dos_findfirst(szFilename, _A_NORMAL, &ffblk); Process(CTRL_M); // genereeer een linefeed/cr while (!done) { rc = 0; // hide(ffblk.name); done = _dos_findnext(&ffblk); } WRITEBYTE(iobase, rc); } void unhide() /* #17 Maak files weer zichtbaar Invoer: filespec als ASCIIZ string Uitvoer: foutcode Deze functie reset van de opgegeven files het Hidden bit. Als er geen files zichtbaar kunnen worden gemaakt dan is de foutcode niet gelijk aan #00. Als er één of meerdere files zichtbaar gemaakt zijn, dan is de foutcode #00. De filespecificatie mag bestaan uit een drive, directory en wildcards. */ { struct find_t ffblk; int done; int rc = 1; leesnaam(); done = _dos_findfirst(szFilename, _A_NORMAL, &ffblk); Process(CTRL_M); // genereeer een linefeed/cr while (!done) { rc = 0; // unhide(ffblk.name); done = _dos_findnext(&ffblk); } WRITEBYTE(iobase, rc); } void info() /* #18 Opvragen file informatie Invoer: filenaam als ASCIIZ string Uitvoer: foutcode file header (16 bytes) attribuut ( 1 byte) tijd en datum van laatste schrijfopdracht De opgegeven file wordt gezocht en indien gevonden wordt de file header overgestuurd naar de Atom. Bij succes is de foutcode #00. De fileheader bevat de volgende informatie: - load adres van file, twee bytes - exec adres van file, twee bytes - dataveld lengte, vier bytes - gereserveerd, acht bytes Aangezien de header in de file zelf is opgeslagen, is de totale file lengte zestien bytes langer dan de doorgegeven lengte; deze bytes zijn niet meegeteld in de dataveld lengte. De tijd en datum van de laatste schrijfopdracht naar de file, normaal gesproken is dat het moment waar de file naar disk is geschreven, wordt in twee woorden doorgegeven. Hiervan hebben de bits de volgende betekenis: Tijd: bit 0-4: seconden/2 (0-29) bit 5-10: minuten (0-59) bit 11-15: uren (0-23) Datum: bit 0-4: dag van de maand (0-31) bit 5-8: maand (1-12) bit 9-15: jaar-1980 (0-127) */ { struct find_t ffblk; int done, aantal, i; unsigned attrib; FILE *input; leesnaam(); done = _dos_findfirst(szFilename, _A_NORMAL,&ffblk); Process(CTRL_M); // genereeer een linefeed/cr while (!done) { if (_dos_getfileattr(szFilename, &attrib) != 0) { WRITEBYTE(iobase, 255); return; } WRITEBYTE(iobase, 0); // geef aan dat file is gevonden if ((input = fopen(szFilename, "rb+")) == NULL) { WRITEBYTE(iobase, 1); // zeg dat de file *niet* geopend is return; } else { aantal = fread(buf, sizeof(char), 16, input); fclose(input); if (aantal == 16) { for (i=0; i<16; i++) { WRITEBYTE(iobase, buf[i]); } WRITEBYTE(iobase, attrib); } else { WRITEBYTE(iobase, 255); return; } } done = _dos_findnext(&ffblk); } WRITEBYTE(iobase, 0); } void geluid() /* #19 Produceer geluid Invoer: toonhoogte (1 byte) toonduur (1 byte) Uitvoer: geen De toonhoogte en de toonduur zijn beiden één byte lang. De maximale toonhoogte ligt rond de waarde 100. Dit is al een behoorlijk hoge toon. De waarden vanaf 128 geven een ongedefinieerde toon. De toonduur wordt gegeven in 18den van seconden. Als de toonhoogte 0 bedraagt dan wordt geen geluid geproduceerd; het commando kan dan gebruikt worden om de opgegeven toonduur te wachten. */ { unsigned hoogte, duur; hoogte = READBYTEW(iobase); duur = READBYTEW(iobase); WinBiep(hoogte, duur); } void bliep() /* #1A Instelling bell-toon Invoer: toonhoogte (1 byte) toonduur (1 byte) Uitvoer: geen Met dit commando worden de toonhoogte en de toonduur ingesteld voor het bell-signaal. Dit is de pieptoon die gegeven wordt voor de ASCII code #07. Wat de waarden betreft zijn deze gelijk als voor het commando #19. */ { unsigned hoogte, duur; hoogte = READBYTEW(iobase); duur = READBYTEW(iobase); WinBiep(hoogte, duur); } void errmsg() /* #1B Druk foutmelding af Invoer: Atom errorcode (1 byte) Uitvoer: geen Dit commando drukt een tekststring, behorende bij de gegeven errorcode, af op het beeldscherm van de PC. Dit schrijven doet de PC zelf. Er wordt geen informatie overgestuurd naar de Atom. */ { int result; result = READBYTEW(iobase); PrintError(result); } void knaagdier() /* #1C Oproepen muisfunctie (PC INT 33) Invoer: registerset (4 words) Uitvoer: registerset (4 words) Hiermee kunnen functies van de PC-muisdriver opgeroepen worden. De registerset bestaat uit acht bytes, die de registers AX, BX, CX en DX van de 8088/80x86 processor voorstellen. Voor het gebuik van deze functie wordt verwezen naar de handleiding voor muizen. */ { unsigned char tab[9]; // 8 posities voor AL, AH .. DL, DH read8b(tab); write8b(tab); } void defmuismasker() /* #1D Definieer muiscursor Invoer: muismasker (64 bytes) Uitvoer: geen Met muisfunctie #09 kan de vorm van de grafische muiscursor opgegeven worden. Deze dient dan echter wel eerst in het geheugen van de PC te staan. Met commando #1D kan de vorm van de muiscursor in het PC geheugen geplaatst worden. Voor het verdere gebruik van deze functie wordt ook verwezen naar de handleiding voor muizen. */ { unsigned char muistab[65]; int i; char szTekst[] = "Deze functie (defmuismasker) heeft binnen windows geen waarde\r\n"; for (i=0; i<64; i++) muistab[i]=READBYTEW(iobase); for (i=0; i<strlen(szTekst); i++) Process(szTekst[i]); } void cursorpos() /* #1E Opvragen cursorpositie Invoer: geen Uitvoer: X en Y coördinaat tekstcursor (2 bytes) Dit commando geeft de positie van de tekstcursor naar de Atom. De linkerbovenhoek is (0,0) */ { WRITEBYTE(iobase, xco); WRITEBYTE(iobase, yco); } void video() /* #1F Oproepen video functies (PC INT 10) Invoer: registerset (4 words) Uitvoer: registerset (4 words) Hiermee kunnen videofuncties van het PC-BIOS opgeroepen worden. De registerset bestaat uit acht bytes, die de registers AX, BX, CX en DX van de 8088/80x86 processor voorstellen. Voor het gebuik van deze functie wordt verwezen naar betreffende literatuur. */ { unsigned char tab[9]; // 8 posities voor AL, AH .. DL, DH char szTekst[] = "Deze functie (Video) heeft binnen windows geen waarde\r\n"; int i; read8b(tab); write8b(tab); for (i=0; i<strlen(szTekst); i++) Process(szTekst[i]); } void serport() /* #20 Oproepen seri‰le communicatie functies (PC INT 14) Invoer: registerset (4 words) Uitvoer: registerset (4 words) Hiermee kunnen communicatiefuncties van het PC-BIOS opgeroepen worden. De registerset bestaat uit acht bytes, die de registers AX, BX, CX en DX van de 8088/80x86 processor voorstellen. Voor het gebuik van deze functie wordt verwezen naar betreffende literatuur. */ { unsigned char tab[9]; // 8 posities voor AL, AH .. DL, DH char szTekst[] = "Deze functie (serport) heeft binnen windows geen waarde\r\n"; int i; read8b(tab); write8b(tab); for (i=0; i<strlen(szTekst); i++) Process(szTekst[i]); } void printit() /* #21 Oproepen printer functies (PC INT 17) Invoer: registerset (4 words) Uitvoer: registerset (4 words) Hiermee kunnen printerfuncties van het PC-BIOS opgeroepen worden. De registerset bestaat uit acht bytes, die de registers AX, BX, CX en DX van de 8088/80x86 processor voorstellen. Voor het gebuik van deze functie wordt verwezen naar betreffende literatuur. */ { unsigned char tab[9]; // 8 posities voor AL, AH .. DL, DH read8b(tab); write8b(tab); } void dosfunctie() /* #22 Oproepen MS-DOS functies (PC INT 21) Invoer: registerset (4 words) Uitvoer: registerset (4 words) Hiermee kunnen MS-DOS systeemfuncties opgeroepen worden. De registerset bestaat uit acht bytes, die de registers AX, BX, CX en DX van de 8088/80x86 processor voorstellen. Omdat niet alle functies uitsluitend gebruik maken van bovengenoemde registers, kunnen sommige functies niet uitgevoerd worden. Voor het gebuik van deze functie wordt verwezen naar betreffende literatuur. */ { unsigned char tab[9]; // 8 posities voor AL, AH .. DL, DH char szTekst[] = "Deze functie (dosfunctie) heeft binnen windows geen waarde\r\n"; int i; read8b(tab); write8b(tab); for (i=0; i<strlen(szTekst); i++) Process(szTekst[i]); } void port_in() /* #23 Lees I/O byte Invoer: I/O adres (1 word) Uitvoer: gelezen data (1 byte) De PC leest het opgegeven I/O adres uit en geeft deze waarde aan de Atom. Het I/O adres ligt in het algemeen in het gebied $0000 - $03FF. */ { unsigned char tab[9]; // 8 posities voor AL, AH .. DL, DH char szTekst[] = "Deze functie (Port_in) heeft binnen windows geen waarde\r\n"; int i; READBYTEW(iobase); READBYTEW(iobase); WRITEBYTE(iobase, 0); for (i=0; i<strlen(szTekst); i++) Process(szTekst[i]); } void port_out() /* #24 Schrijf I/O byte Invoer: I/O adres (1 word) data (1 byte) Uitvoer: geen De PC stuurt de data naar het opgegeven I/O adres. Het I/O adres ligt in het algemeen in het gebied $0000 - $03FF. */ { unsigned char tab[9]; // 8 posities voor AL, AH .. DL, DH char szTekst[] = "Deze functie (Port_in) heeft binnen windows geen waarde\r\n"; int i; READBYTEW(iobase); READBYTEW(iobase); WRITEBYTE(iobase, 0); for (i=0; i<strlen(szTekst); i++) Process(szTekst[i]); } void uds() /* #25 Defini‰er grafische letter Invoer: ASCII waarde van karakter (1 byte) karakter patroon (16 bytes) Uitvoer: geen Karakters die met commando #07 in de grafische mode geschreven worden kunnen met deze functie gedefini‰erd worden. Het eerst gelezen byte vormt de bovenste regel van het karakter. */ { unsigned char ascii; int i; unsigned char tab[17]; ascii = READBYTEW(iobase); for (i=0; i< 16; i++) tab[i]=READBYTEW(iobase); } void mouse_mot() /* #26 Opvragen muis aktiviteiten Invoer: geen Uitvoer: horizontale beweging (1 byte) vertikale beweging (1 byte) status van knoppen (1 byte) Deze functie biedt de mogelijk om snel de beweging van de muis op te vragen. Dit is relatief t.o.v. de laatst gelezen positie. */ { WRITEBYTE(iobase, 0); // hor WRITEBYTE(iobase, 0); // ver WRITEBYTE(iobase, 0); // buttons } void whoami() /* #27 Opvragen PC informatie Invoer: geen Uitvoer: PC identificatie (1 word) Het PC identificatie woord geeft enige informatie omtrent de beschikbare hardware die op de PC is aangesloten. Dit woord is als volgt samengesteld: bit 0 gezet als drive(s) aanwezig bit 1 gezet als 80x87 coprocessor aanwezig is bit 2 pc type (0=XT, 1=AT) bit 3 video type (1=Hercules mono, 0=kleurenkaart) bit 4,5 video mode bij opstarten bit 6,7 aantal drives als bit 0 gezet is bit 8 --- bit 9,11 aantal seri‰le poorten bit 12,13 video kaart (00=CGA, 01=EGA, 10=VGA, 11=HGC) bit 14,15 aantal printerpoorten De bits 12 en 13, welke het type videokaart aangeven, kunnen vanuit de MS-DOS commandline met de optie /V= gezet worden. De niet gebruikte bits zijn '0'. Deze kunnen in de toekomst nog ingevuld worden. */ { WRITEBYTE(iobase, 0xa9); WRITEBYTE(iobase, 0x7b); } void clear0() /* #28 Emulatie clear 0 Invoer: video adres (1 word) video data (1 byte) Uitvoer: geen De opgegeven data wordt overeenkomstig met Atom grafics op het beeldscherm weergegeven. De positie van deze data wordt opgegeven met het videoadres. V¢¢r het gebruik van dit commando dient het font ATOMVDU.FNT geladen te zijn m.b.v. commando #06. Dit is nodig omdat bij het emuleren van CLEAR 0 gebruik wordt gemaakt van een karaktertabel. Bij de Windows versie, wordt verondersteld dat er met het standaard ATOM.TTF wordt gewerkt. Na correcte installatie is het niet nodig verdere actie te ondernemen. */ { unsigned int adres; unsigned char data; int lxco, lyco; adres = ((READBYTEW(iobase) & 255) * 256) + READBYTEW(iobase); data = READBYTEW(iobase); // inhoud van het adres if (adres < 0x8200&& adres >0x7fff) { // ligt binnen video plane lxco = (adres-0x8000) % 32; lyco = (adres-0x8000) / 32; if (data < 0x20) data = data + 0x40; else if (data >=0x40 && data < 0x60) data = data + 0x40; else if (data >=0x60 && data < 0x80) data = data + 0x40; else if (data >=0x80 && data < 0xA0) data = data - 0x20; else if (data >=0xa0 && data < 0xc0) data = data + 0x20; else if (data >=0xc0 && data < 0xe0) data = data + 0x20; else if (data >=0xe0) data = data - 0x20; paintclear0(lxco, lyco, data); } } void palet() /* #29 Wijzigen van palet of achtergrondkleur in CGA modi Invoer: paletnummer of kleurnummer (1 byte) Uitvoer: geen In de grafische modi kan met deze functie gekozen worden tussen de twee kleurensets van een CGA kaart. Als bit 7 van de kleur gezet is dan wordt de achtergrondkleur ingesteld. Palet 0: groen, rood, geel Palet 1: ultramarijn, violet, wit Dit commando kan ook gebruikt worden in tekstmode. In dat geval wordt, indien bit 7 gezet is, de kaderkleur van het scherm ingesteld. */ { READBYTE(iobase); } void clear1() /* #2A t/m #31 Emulatie grafische Atom modi Deze commando's werken op dezelfde manier als commando #28. De ge‰muleerde modi zijn: #2A clear 1 monochroom In de kleurenmodi kan met behulp van commando #29 gekozen worden tussen twee kleurensets. In monochroom modi kan op dezelfde wijze een van de achtergrondkleuren gekozen worden. Dus monochroom is niet altijd zwart/wit. Voor emulatie van een van deze modi hoeft geen speciale karakterset geladen te worden. */ { unsigned int adres; BYTE data; unsigned int result; adres = ((READBYTEW(iobase) & 255) * 256) + READBYTEW(iobase); data = READBYTEW(iobase); // inhoud van het adres if (adres < 0x8400 && adres >0x7fff) { // ligt binnen video plane SetByte((MIRROR(adres)-0x8000), data, 0x10); } } void clear1a() /* #2A t/m #31 Emulatie grafische Atom modi Deze commando's werken op dezelfde manier als commando #28. De ge‰muleerde modi zijn: #2B clear 1 kleur 00 groen 01 geel 02 blauw 03 rood In de Winatom moeten deze bitwaardes vertaald worden naar resp. 0B, 0C 0D en 0A. Dit omdat er in de aange- maakte DIB vier bits per kleur worden gebruikt. Het omschakelen van pallet met de daarbij horende gevol- gen moet nog worden uitgewerkt. In de kleurenmodi kan met behulp van commando #29 gekozen worden tussen twee kleurensets. In monochroom modi kan op dezelfde wijze een van de achtergrondkleuren gekozen worden. Dus monochroom is niet altijd zwart/wit. Voor emulatie van een van deze modi hoeft geen speciale karakterset geladen te worden. */ { unsigned int adres; BYTE data; unsigned int result; adres = ((READBYTEW(iobase) & 255) * 256) + READBYTEW(iobase); data = READBYTEW(iobase); // inhoud van het adres if (adres < 0x8400&& adres >0x7fff) { // ligt binnen video plane SetByte((MIRROR(adres)-0x8000), data, 0x1a); } } void clear2() /* #2A t/m #31 Emulatie grafische Atom modi Deze commando's werken op dezelfde manier als commando #28. De ge‰muleerde modi zijn: #2C clear 2 monochroom In de kleurenmodi kan met behulp van commando #29 gekozen worden tussen twee kleurensets. In monochroom modi kan op dezelfde wijze een van de achtergrondkleuren gekozen worden. Dus monochroom is niet altijd zwart/wit. Voor emulatie van een van deze modi hoeft geen speciale karakterset geladen te worden. */ { unsigned int adres; BYTE data; unsigned int result; adres = ((READBYTEW(iobase) & 255) * 256) + READBYTEW(iobase); data = READBYTEW(iobase); // inhoud van het adres if (adres < 0x8800&& adres >0x7fff) { // ligt binnen video plane SetByte((MIRROR(adres)-0x8000), data, 0x20); } } void clear2a() /* #2A t/m #31 Emulatie grafische Atom modi Deze commando's werken op dezelfde manier als commando #28. De ge‰muleerde modi zijn: #2D clear 2 kleur In de kleurenmodi kan met behulp van commando #29 gekozen worden tussen twee kleurensets. In monochroom modi kan op dezelfde wijze een van de achtergrondkleuren gekozen worden. Dus monochroom is niet altijd zwart/wit. Voor emulatie van een van deze modi hoeft geen speciale karakterset geladen te worden. */ { unsigned int adres; BYTE data; unsigned int result; adres = ((READBYTEW(iobase) & 255) * 256) + READBYTEW(iobase); data = READBYTEW(iobase); // inhoud van het adres if (adres < 0x8600&& adres >0x7fff) { // ligt binnen video plane SetByte((MIRROR(adres)-0x8000), data, 0x2a); } } void clear3() /* #2A t/m #31 Emulatie grafische Atom modi Deze commando's werken op dezelfde manier als commando #28. De ge‰muleerde modi zijn: #2E clear 3 monochroom In de kleurenmodi kan met behulp van commando #29 gekozen worden tussen twee kleurensets. In monochroom modi kan op dezelfde wijze een van de achtergrondkleuren gekozen worden. Dus monochroom is niet altijd zwart/wit. Voor emulatie van een van deze modi hoeft geen speciale karakterset geladen te worden. */ { unsigned int adres; BYTE data; unsigned int result; adres = ((READBYTEW(iobase) & 255) * 256) + READBYTEW(iobase); data = READBYTEW(iobase); // inhoud van het adres if (adres < 0x8c00&& adres >0x7fff) { // ligt binnen video plane SetByte((MIRROR(adres)-0x8000), data, 0x30); } } void clear3a() /* #2A t/m #31 Emulatie grafische Atom modi Deze commando's werken op dezelfde manier als commando #28. De ge‰muleerde modi zijn: #2F clear 3 kleur In de kleurenmodi kan met behulp van commando #29 gekozen worden tussen twee kleurensets. In monochroom modi kan op dezelfde wijze een van de achtergrondkleuren gekozen worden. Dus monochroom is niet altijd zwart/wit. Voor emulatie van een van deze modi hoeft geen speciale karakterset geladen te worden. */ { unsigned int adres; BYTE data; unsigned int result; adres = ((READBYTEW(iobase) & 255) * 256) + READBYTEW(iobase); data = READBYTEW(iobase); // inhoud van het adres if (adres < 0x8c00&& adres >0x7fff) { // ligt binnen video plane SetByte((MIRROR(adres)-0x8000), data, 0x3a); } } void clear4() /* #2A t/m #31 Emulatie grafische Atom modi Deze commando's werken op dezelfde manier als commando #28. De ge‰muleerde modi zijn: #30 clear 4 monochroom In de kleurenmodi kan met behulp van commando #29 gekozen worden tussen twee kleurensets. In monochroom modi kan op dezelfde wijze een van de achtergrondkleuren gekozen worden. Dus monochroom is niet altijd zwart/wit. Voor emulatie van een van deze modi hoeft geen speciale karakterset geladen te worden. */ { unsigned int adres; BYTE data; unsigned int result, mir; adres = ((READBYTEW(iobase) & 255) * 256) + READBYTEW(iobase); mir = MIRROR(adres); data = READBYTEW(iobase) & 255; // inhoud van het adres if (mir > 0x7fff && mir <0x9800) { SetByte(mir-0x8000, data, 0x40); } } void clear4a() /* #2A t/m #31 Emulatie grafische Atom modi Deze commando's werken op dezelfde manier als commando #28. De ge‰muleerde modi zijn: #31 clear 4 kleur In de kleurenmodi kan met behulp van commando #29 gekozen worden tussen twee kleurensets. In monochroom modi kan op dezelfde wijze een van de achtergrondkleuren gekozen worden. Dus monochroom is niet altijd zwart/wit. Voor emulatie van een van deze modi hoeft geen speciale karakterset geladen te worden. */ { unsigned int adres; BYTE data; unsigned int result; adres = ((READBYTEW(iobase) & 255) * 256) + READBYTEW(iobase); data = READBYTEW(iobase); // inhoud van het adres if (adres < 0x9800&& adres >0x7fff) { // ligt binnen video plane SetByte((MIRROR(adres)-0x8000), data, 0x4a); } } void videomod() /* #32 Inschakelen extended video mode Invoer: schermmode (1 byte) Uitvoer: geen De PC schakelt de aanwezige videokaart over naar de opgegeven mode. Hiermee kunnen dus hogere grafische modi opgeroepen worden. De toegestane waarden zijn afhankelijk van de aanwezige videokaart. Als een extended video mode gekozen wordt dient het tekstvenster met de juiste waarden gedefinieerd te worden om problemen bij het scrollen te voorkomen. Of de muis gebruikt kan worden in deze modi is afhankelijk van de gebruikte muisdriver. */ { READBYTEW(iobase); // clrscr(); } void videocol() /* #33 Zet graphics kleur voor extended video mode Invoer: pixelkleur (1 byte) Uitvoer: geen De opgegeven kleur wordt gebruikt bij plot opdrachten in extended video modi. De toegestane waarden zijn afhankelijk van de videomode. */ { kleur = READBYTEW(iobase); } void schrijfpix() /* #34 Schrijf grafisch pixel in extended video mode Invoer: X-coördinaat (1 word) Y-coördinaat (1 word) plot opdracht (1 byte) Uitvoer: geen Met dit commando kunnen punten in de extended video modi gezet of gewist worden. De bewerking wordt gegeven door de plot opdracht, 1=zet pixel, 2=wis pixel en 3=exor pixel met kleur. De X en Y-coördinaten zijn afhankelijk van de grafische resolutie van de geselecteerde video mode. In theorie kan een resolutie van 65535*65535 met 256 kleuren gebruikt worden. Slechts weinig videokaarten ondersteunen deze mode. Let erop dat in extended video modi de punt (0,0) links boven op het scherm is en niet zoals bij de Atom modi links onder! */ { unsigned int x,y; unsigned int plot; unsigned int result; x = ((READBYTEW(iobase) & 255) * 256) + READBYTEW(iobase); y = ((READBYTEW(iobase) & 255) * 256) + READBYTEW(iobase); result = READBYTEW(iobase); plot = result & 255; if (plot == 1) plot = kleur; else if (plot == 2) plot = kleur | 0x80; else plot = kleur ^ -1; pixel(x, y, plot); // 65532, 65532, 255 } void windowd() /* #35 Instellen tekstvenster Invoer: X-links onder (1 byte) Y-links onder (1 byte) X-rechts boven (1 byte) Y-rechts boven (1 byte) Uitvoer: geen Het tekstvenster kan met dit commando ingesteld worden. Alle door de Atom geproduceerde beeldscherm uitvoer wordt in dit venster afgedrukt. Uitvoer die door de PC op het scherm afgebeeld wordt zoals een catalog of foutmelding kan buiten het venster vallen. Zoals bij de beschrijving van commando #32 al is vermeld moeten bij extended video modi de tekstvensters expliciet opgegeven worden. De windowbreedte klopt meestal wel, maar de hoogte is altijd 25 regels. Dit omdat in het PC- BIOS wel het aantal tekens per regel kan worden opgevraagd, maar niet het aantal regels per scherm. Daarom is gekozen voor de meest voorkomende waarde van 25 regels per scherm. */ { venster_xlo = READBYTEW(iobase); // coordinaten tekstvenster venster_ylo = READBYTEW(iobase); // venster_xrb = READBYTEW(iobase); // venster_yrb = READBYTEW(iobase); // xco = venster_xlo; yco = venster_ylo; regels = 0; } void window_off() /* #36 Opheffen tekstvenster Invoer: geen Uitvoer: geen Dit (overbodige) commando heft een gedefini‰erd tekstvenster op. */ { // schermbreedte opvragen venster_xlo = 0; // coordinaten tekstvenster venster_ylo = 24; // venster_xrb = 80; // beetje anders dus venster_yrb = 0; // } void joystick() /* #37 Joystick uitlezen Invoer: geen Uitvoer: stand joystick en vuurknoppen De analoge joystick van de PC wordt uitgelezen en omgezet naar digitale waarden die voor de Atom joystick gebruikelijk zijn. Voor de volledigheid de betekenis van de afzonderlijke bits:
pccom37.gif
*/ { WRITEBYTE(iobase, joystat); } void callibrate() /* #38 Joystick calibreren Invoer: geen Uitvoer: geen Een analoge joystick moet altijd gecalibreerd worden. Bij deze gebeurtenis wordt de stand van de joystick gelezen en deze stand wordt als "neutraal" beschouwd. Alle joystick bewegingen gelden ten opzichte van deze neutraalstand. Bij het opstarten van het terminal programma en bij een reset van de Atom wordt de joystick automatisch gecalibreerd; deze functie is alleen nodig indien tijdens het werken met de Atom van joystick gewisseld wordt of als de PC van snelheid veranderd. Dit laatste geval omdat het uitlezen van de joystick tijdafhankelijk is. */ { } void bit7() /* #39 Masker bit 7 instellen Invoer: 0 -> bit 7 is altijd '0' 1 -> bit 7 blijft ongewijzigd. Uitvoer: geen De ascii-codes #00 t/m #1F worden door de Atom als controlcodes opgevat. De PC kent echter voor deze codes ook nog een aantal symbolen. Als het masker voor bit 7 gezet is, worden alle ascii-codes normaal afgehandeld; als dit masker gewist is wordt van ieder, op het scherm af te drukken karakter, bit 7 gewist. Hiermee kunnen de speciale symbolen door middel van de ascii waarden #80 t/m #9F ook op het scherm afgebeeld worden. */ { unsigned char waarde; waarde = READBYTEW(iobase); if (waarde !=0) msb = 0xff; else msb = 0x7f; } void bioskey() /* #3A Oproepen keyboard functies (PC INT 16) Invoer: registerset (4 words) Uitvoer: registerset (4 words) Hiermee kunnen de keyboard functies van het PC-BIOS opgeroepen worden. De registerset bestaat uit acht bytes, die de registers AX, BX, CX en DX van de 8088/80x86 processor voorstellen. Voor het gebuik van deze functie wordt verwezen naar betreffende literatuur. Let erop dat er bij het gebruik van deze interrupt verschillen kunnen zijn bij de XT en AT! */ { unsigned char tab[9]; // 8 posities voor AL, AH .. DL, DH char szTekst[] = "Deze functie (dosfunctie) heeft binnen windows geen waarde\r\n"; int i; read8b(tab); write8b(tab); for (i=0; i<strlen(szTekst); i++) Process(szTekst[i]); } void shell() /* #3B Shell naar DOS Invoer: MSDOS commando als ASCIIZ string Uitvoer: geen Als men tijdens het werken behoefte krijgt om een MS-Dos programma te gebruiken (bijvoorbeeld FORMAT of DISKCOPY) kan met dit commando ieder geldig MS-DOS commando uitgevoerd worden. Als men tijdelijk naar MS-DOS wil kan dat door het opstarten van een tweede COMMAND.COM. Geef om terug te keren naar de Atom dan het commando EXIT. */ { } void zoekfile() /* #3C Zoek eerste passende file Invoer: filespecificatie als ASCIIZ string Uitvoer: resultaat (1 byte) DTA informatie (22 bytes) MS-DOS biedt de mogelijkheid om files te zoeken die voldoen aan de opgegeven filespecificatie. Hierin mogen wildcards * en ? voorkomen. Dit zoeken naar files gaat in twee stappen. Bij de eerste zoekactie dient dit commando gebruikt te worden. Als een file gevonden is dan wordt als resultaat een 0 overgezonden. Het resultaat geeft de foutcode weer als geen passende file gevonden is; in dat geval volgt er geen DTA. In de DTA, dit staat voor Disk Transfer Area, is alle MS- DOS directory informatie opgenomen. Voor de exacte inhoud wordt verwezen naar bijlage II. */ { struct find_t ffblk; int done, i; char tekst[80]; char far *dta; /* leesnaam(); if (strlen(szFilename) == 0) strcpy(szFilename, "*.*"); // WRITEBYTE(iobase, 255); // geen naam opgegeven tulpekop! done = _dos_findfirst(szFilename, _A_NORMAL,&ffblk); if (!done) { WRITEBYTE(iobase, 0); // geef aan dat het goed gegaan // dta = getdta(); // printf("The current disk transfer address is: %Fp\n", dta); // WRITEBYTE(iobase, dta[22]); // hier iets voor test } else { WRITEBYTE(iobase, 255); } */ WRITEBYTE(iobase, 0); // geef aan dat het goed gegaan } void zoeknext() /* #3D Zoek volgende passende file Invoer: geen Uitvoer: resultaat (1 byte) DTA informatie (22 bytes) De tweede stap bij het zoeken naar files krijgt geen parameters mee omdat deze nog bekend is vanuit de eerste zoekactie. Een voorwaarde is dat er tussen twee zoektochten geen disk activiteiten hebben plaats gevonden. De teruggegeven informatie is het zelfde als bij functie #3C. */ { struct find_t ffblk; int done, i; char tekst[80]; char far *dta; done = _dos_findnext(&ffblk); if (!done) { WRITEBYTE(iobase, 0); // geef aan dat het goed gegaan dta = getdta(); } else { WRITEBYTE(iobase, 0); // geef aan dat er nix te verhapstukken is } } void lpt() /* #3E Selecteer printer Invoer: printernummer (1 byte) Uitvoer: printerstatus (1 byte) Met deze functie wordt een printer gekozen die aangesproken wordt als de printer aangezet wordt met $2 of CTRL-B. De uitvoer is de status van de betreffende printer. Als deze status #90 bedraagt is de printer gereed om data te ontvangen en af te drukken. */ { READBYTEW(iobase); WRITEBYTE(iobase, 0x90); } void raf_open() /* #3F Open random access file Invoer: filenaam als ASCIIZ-string file-attribuut (1 byte) Uitvoer: handle (1 byte) Bij het openen van een file bepaalt het attribuut op welke wijze de file aangesproken mag worden. De volgende attributen worden geaccepteerd: #00 alleen lezen #01 alleen schrijven #02 lezen en schrijven De computer zoekt het opgegeven bestand. Als dit gevonden is wordt het geopend voor de gewenste toegang. Bestanden waarnaar geschreven mag worden worden aangemaakt als zij niet gevonden worden. Bij een niet geopend bestand is de afgegeven handle 0; het is niet te achterhalen waarom de file niet gevonden is. Iedere andere waarde voor de handle duidt erop dat de file geopend is. */ { unsigned char attrib; int handle, bx, i; unsigned nBytes; leesnaam(); attrib = READBYTEW(iobase) & 0x03; if (_dos_open(szFilename, O_RDWR, &handle) == 0) { lseek(handle, 16L, SEEK_SET); WRITEBYTE(iobase, handle); } else { if (attrib == 0) { WRITEBYTE(iobase, 1); // geef foutcode aan } else { if (_dos_creat(szFilename, _A_NORMAL, &handle) != 0) { WRITEBYTE(iobase, 0); // geef foutcode aan } else { for (i=0; i<16; i++) buffer[i]=0x00; nBytes=16; bx = _dos_write(handle, buffer, sizeof(buffer), &nBytes); WRITEBYTE(iobase, bx); } } } } void raf_sluit() /* #40 Sluit random access file Invoer: handle (1 byte) Uitvoer: geen De opgegeven file wordt afgesloten en de handle wordt vrijgegeven. De handle moet een waarde hebben groter dan 4 omdat anders een MS-DOS standaard apparaat gesloten kan worden. Zie bijlage II. */ { int handle; handle=READBYTEW(iobase); close(handle); } void raf_schrijf() /* #41 Schrijf byte naar random access file Invoer: handle (1 byte) data (1 byte) Uitvoer: resultaat (1 byte) De data wordt naar de file met de betreffende handle gestuurd. Bij succes is het resultaat 1. Een resultaat 0 geeft aan dat er geen byte meer naar de file geschreven kon worden; de disk is dan vol. */ { FILE * handle; unsigned char data[1], rc; handle=(FILE *) READBYTEW(iobase); data[0]=READBYTEW(iobase); rc = fwrite(data, sizeof(data), 1, handle); WRITEBYTE(iobase, rc); } void raf_lezen() /* #42 Lees byte van random access file Invoer: handle (1 byte) Uitvoer: resultaat (1 byte) data (1 byte) De data wordt van de file met de betreffende handle gelezen. Bij succes is het resultaat 1. Een resultaat 0 geeft aan dat er geen byte meer gelezen kon worden; het einde van de file is dan bereikt. Er moet dan toch nog een leesopdracht plaats vinden omdat de PC een willekeurig byte overstuurd. */ { FILE * handle; unsigned char data[1], rc; handle=(FILE *) READBYTEW(iobase); rc = fread(&data, sizeof(data), 1, handle); WRITEBYTE(iobase, data[0]); WRITEBYTE(iobase, rc); } void raf_move_ptr() /* #43 Verplaats random access file pointer Invoer: handle (1 byte) offset van pointer (4 bytes) offset code (1 byte) Uitvoer: resultaat (1 byte) absolute waarde van pointer (4 bytes) De pointer naar een random access file kan met deze functie opgevraagd worden. Hiertoe wordt eerst de handle van de betreffende file gegeven en daarna een 32 bits offset voor de pointer. Tenslotte volgt de offset code, hiermee wordt aangegeven hoe de offset geinterpreteerd dient te worden: 0: offset heeft betrekking op begin van het bestand 1: offset heeft betrekking op acuele positie van pointer 2: offset heeft betrekking op einde van het bestand Als er geen fout optreed is het resultaat 0, gevolgd door de waarde van de pointer ten opzichte van het begin van het bestand. De offset mag 0 of negatief zijn bij offset codes 1 en 2. Het is zelfs mogelijk om de pointer voor het begin of achter het eind van het bestand te zetten. Hiervoor wordt geen foutmelding gegeven. De fout treedt pas op bij de eerstvolgende lees of schrijfopdracht voor die file. Met dit commando kan de actuele waarde van de pointer opgevraagd worden door een offset 0 te geven en offset code 1; hierdoor wordt de pointer 0 bytes verplaatst ten opzichte van de actuele positie -> deze blijft dus staan. */ { long int offset, roffset; char * poffset; int i; int handle; unsigned char offsetcode, rc = 0; poffset = (char *) &offset; handle = READBYTEW(iobase); for (i=0; i< sizeof(long int); i++) *poffset++ = READBYTEW(iobase); offsetcode = READBYTEW(iobase); roffset = lseek(handle, offset, offsetcode); poffset = (char *) &roffset; for (i=0; i< sizeof(long int); i++) WRITEBYTE(iobase, *poffset++); if (roffset == -1) rc = errno; WRITEBYTE(iobase, rc); } void raf_lees_ext() /* #44 Opvragen extensie van random access file Invoer: handle (1 byte) Uitvoer: resultaat (1 byte) extensie van file (4 bytes) De extensie is in dit geval niet het laatste stukje van de filenaam maar de lengte van de file. Bij een resultaat 0 volgt de lengte van de file. */ { unsigned long offset; char * poffset = (char *) &offset; int i; int handle; unsigned char rc=0; handle = READBYTEW(iobase); offset = filelength(handle); poffset = (char *) &offset; if (offset == -1) rc = errno; WRITEBYTE(iobase, rc); for (i=0; i< sizeof(unsigned long); i++) WRITEBYTE(iobase, *poffset++); } void mousekar() /* #45 Lees teken onder muiscursor Invoer: geen Uitvoer: teken onder muiscursor (1 byte) Deze functie is analoog aan functie #02, behalve dat nu het karakter gelezen wordt op de plaats van de muiscursor; deze functie werkt alleen in tekstmodi 40*25 en 80*25. */ { WRITEBYTE(iobase, scherm[rb_xco][rb_yco]); } void versie() /* #46 Opvragen versienummer terminal programma Invoer: geen Uitvoer: release/update nummer (1 byte) hoofdversienummer (1 byte) Het is zinnig om het versienummer van het terminal programma op te vragen als er gebruik wordt gemaakt van deze serie PC-commando's. Hiermee kan de gebruiker gewaarschuwd worden dat hij/zij mogelijk een recentere versie van het terminal programma dient te gebruiken. Alle commando's in deze handleiding zijn beschikbaar vanaf versie 2.20. */ { WRITEBYTE(iobase, VER_HI); WRITEBYTE(iobase, VER_LO); } void teken2lpt() /* #47 Teken naar printer sturen Invoer: teken (1 byte) Uitvoer: geen Het gelezen teken wordt naar de printer gestuurd indien deze aangezet is met $2 of ^B. Als de printer niet aange- zet is dan voert dit commando niets uit. In het geval dat de printer wel aangezet is maar de printer is niet on- line wordt gewacht totdat de printer on-line komt. */ { char teken[1]; teken[0] = READBYTEW(iobase); if (bPrinterstatus == TRUE) { fwrite(&teken, sizeof(char), 1, prnfile); } } void cgabitmap() /* #48 CGA grafisch teken defini‰ren Invoer: ascii waarde van teken (1 byte) bitpatroon van teken (8 bytes) Uitvoer: geen In de grafische CGA mode is het mogelijk om zelf de tekens 128 t/m 255 te defini‰ren (iets dat MS-DOS doet met het commando GRAFTABL). Deze mogelijkheid is nu ook beschikbaar voor de Atom. Nadat de ascii waarde van het te defini‰ren teken is overgezonden worden de volgende acht bytes opgeslagen als bitpatroon. De nieuwe tekens worden in hetzelfde gebied opgeslagen als het font voor GTEXT en Atomvdu; het is dus niet mogelijk om deze drie fonts gelijktijdig te gebruiken of de fonts moeten om en om geladen worden. Het is al aan te voelen dat een komplete karakterset geladen kan worden. Om een nieuwe karakterset te laden kan het bekende FONT statement gebruikt worden. */ { int i; for (i=0; i<9; i++) { READBYTE(iobase); } } void hfill() /* #49 Horizontaal vullen Invoer: coördinaten beginpunt (2 words) grenskleur (1 byte) Uitvoer: geen Vanaf het opgegeven punt wordt de beeldlijn naar links en naar rechts gekleurd in de aktuele kleur. Dit kleuren gaat door totdat een pixel ontmoet wordt dat gelijk is aan de grenskleur. Bij het kleuren wordt rekening gehouden met een eventueel grafisch venster en een verschoven oorsprong. Voorwaarde is wel dat het beginpunt in het grafisch venster ligt. */ { } void vfill() /* #4A Vertikaal vullen Invoer: coördinaten beginpunt (2 words) grenskleur (1 byte) Uitvoer: geen Vanaf het opgegeven punt wordt de beeldlijn naar boven en naar beneden gekleurd in de aktuele kleur. Dit kleuren gaat door totdat een pixel ontmoet wordt dat gelijk is aan de grenskleur. Bij het kleuren wordt rekening gehouden met een eventueel grafisch venster en een verschoven oorsprong. Voorwaarde is wel dat het beginpunt in het grafisch venster ligt. */ { } void roep61() /* #4B Aanroepen INT 61h Invoer: afhankelijk van aangeroepen programma Uitvoer: afhankelijk van aangeroepen programma Om het Atom terminal programma zelf uit te breiden kan op de PC een resident programma gestart worden dat geakti- veerd wordt bij een oproep van INT 61h. Parameters en resultaten kunnen afhankelijk van het opgeroepen program- ma uitgewisseld worden. Zie het hoofdstuk "communicatie met andere programma's" voor meer uitleg. */ { } void gwindow() /* #4C Defini‰er een grafisch venster Invoer: X-coördinaat linker benedenhoek (1 word) X-coördinaat linker benedenhoek (1 word) Y-coördinaat rechter bovenhoek (1 word) Y-coördinaat rechter bovenhoek (1 word) Uitvoer: geen Voor de Atom grafische mode bood het Gagsrom al mogelijk- heden voor grafische vensters. Voor de extended video mode kan dit commando gebruikt worden om een grafisch venster vast te leggen. Dat houdt in dat alleen binnen dat venster getekend kan worden. Na het gebruiken van een CLEAR opdracht wordt het venster automatisch opgeheven. */ { gwindow_xlo = ((READBYTEW(iobase) & 255) * 256) + READBYTEW(iobase); gwindow_xrb = ((READBYTEW(iobase) & 255) * 256) + READBYTEW(iobase); gwindow_ylo = ((READBYTEW(iobase) & 255) * 256) + READBYTEW(iobase); gwindow_yrb = ((READBYTEW(iobase) & 255) * 256) + READBYTEW(iobase); } void gwoff() /* #4D Grafisch venster opheffen Invoer: geen Uitvoer: geen Hiermee wordt een grafisch venster opgeheven. */ { gwindow_xlo = 0; gwindow_ylo = -1; gwindow_xrb = -1; gwindow_yrb = 0; } void oorsprong() /* #4E Grafische oorsprong verschuiven Invoer: coördinaten van nieuwe oorsprong (2 words) Uitvoer: geen Het grafische nulpunt ligt normaal in de linker bovenhoek van het scherm. Met dit commando kan het punt (0,0) verschoven worden naar een willekeurige plaats op het scherm. Bij het verschuiven van de grafische oorsprong wordt geen rekening gehouden met een eerder verschoven oorsprong en een grafisch venster. De nieuwe positie is dus altijd ten opzichte van de linker bovenhoek van het scherm. Na een CLEAR opdracht bevindt de oorsprong zich altijd in de linker bovenhoek. */ { int x, y; x = ((READBYTEW(iobase) & 255) * 256) + READBYTEW(iobase); y = ((READBYTEW(iobase) & 255) * 256) + READBYTEW(iobase); } void viewscherm() /* #4F Selecteer schermpagina voor monitor Invoer: schermpagina nummer (1 byte) Uitvoer: geen Bij gebruik van een tekstmode kan gebruik gemaakt worden van verschillende schermpagina's. Er zijn in feite twee mogelijkheden bij het werken met verschillende pagina's, te weten: werkpagina is zichtbaar op scherm of de werkpa- gina en de getoonde pagina zijn verschillend. Met het commando #4F kan de pagina gekozen worden die op de monitor getoond wordt. Zie voor meer informatie het hoofdstuk "Schermpagina's". */ { schermpag = READBYTEW(iobase); } void werkscherm() /* #50 Selecteer schermpagina voor bewerkingen Invoer: schermpagina nummer (1 byte) Uitvoer: geen Bij gebruik van een tekstmode kan gebruik gemaakt worden van verschillende schermpagina's. Er zijn in feite twee mogelijkheden bij het werken met verschillende pagina's, te weten: werkpagina is zichtbaar op scherm of de werkpa- gina en de getoonde pagina zijn verschillend. Met het commando #50 kan de pagina gekozen worden waar de schrijfopdrachten naar toe gestuurd worden. Zie voor meer informatie het hoofdstuk "Schermpagina's". */ { schermpag = READBYTEW(iobase); } void cursordef() /* #51 Zet cursor lijnen Invoer: bovenste cursorlijn (1 byte) onderste cursorlijn (1 byte) Uitvoer: geen De vorm van de cursor kan ingesteld worden met dit com- mando. De cursorlijnen worden van boven naar beneden geteld. De eerste parameter zal dus altijd groter zijn dan de tweede. Bij ongeldige waarden verdwijnt de cursor van het scherm. Het aantal lijnen verschilt per video- kaart. */ { char cur_lo, cur_hi; cur_hi = READBYTEW(iobase); cur_lo = READBYTEW(iobase); } void read_b001(unsigned char status) /* */ { unsigned char toets = 0xff; if (status & SHFTMASK) toets &= 0x7f; if (status & CTRLMASK) toets &= 0xbf; if (adres_b000 != 0xff) status &= kbmatrix[status]; WRITEBYTE(iobase, status); /* MOV BL,AL ; BEWAAR STATUS VAN JOYSTICK MOV AH,2 ; LEES KEYBOARD STATUS INT 16H TEST AL,00000011B ; TEST OP SHIFTTOETS JE READ1 ; SPRING INDIEN GEEN SHIFTTOETS AND BL,01111111B ; ZET SHIFT BIT READ1: TEST AL,00000100B ; TEST OP CONTROL TOETS JE READ2 ; SPRING INDIEN GEEN CONTROL TOETS AND BL,10111111B ; ZET CTRL BIT READ2: XOR AH,AH ; BEPAAL RIJ VAN KEYBOARD MATRIX MOV AL,ADRES_B000 CMP AL,0FFH ; KIJK OF 8255 EMULATIE AANSTAAT JE READ2A ; SPRING INDIEN NIET AKTIEF MOV SI,AX ; ZET RIJ IN INDEXREGISTER MOV AL,BL ; ZET RESULTAAT IN AL AND AL,KEYMATRIX[SI]; LEES STATUS VAN ATOM-TOETSENBORD READ2A: CALL ZENDBYTE ; STUUR NAAR DE ATOM JMP LEESCOM ; EINDE ROUTINE */ } void read_b002() /* */ { /* READ_B002: MOV BL,6FH ; ZET INITIELE WAARDE MOV AH,2 ; LEES KEYBOARD STATUS INT 16H TEST AL,08H ; TEST OP ALT TOETS JE READ3 ; SPRING INDIEN GEEN ALT TOETS AND BL,0BFH ; WIS BIT VOOR ALT TOETS */ unsigned char status; READ3: asm IN AL,40H // LEES LAGE BYTE VAN TIMER 0 asm TEST AL,02H // TEST LAGE BIT "2400 HZ" asm JE READ4 // SPRING INDIEN 0 asm OR BL,10H // ZET "2400 HZ" BIT READ4: asm IN AL,40H // LEES HOGE BYTE VAN TIMER 0 asm TEST AL,80H // TEST HOGE BIT "60 HZ" asm JE READ5 // SPRING INDIEN 0 asm OR BL,80H // ZET "60 HZ" BIT READ5: asm MOV status,BL // ZET RESULTAAT IN AL WRITEBYTE(iobase, status); /* CALL ZENDBYTE ; STUUR NAAR ATOM JMP LEESCOM ; EINDE ROUTINE */ } void write_b000() /* */ { READBYTEW(iobase); } void egafont() /* #55 Selecteer user font voor EGA/VGA tekstmode Invoer: geen Uitvoer: geen Dit commando laadt het geladen font in het fontram van de EGA of VGA kaart. Hiermee kunnen de karakters in tekstmo- de gewijzigd worden. */ { } void ega8x14() /* #56 Selecteer EGA 8*14 ROM font Invoer: geen Uitvoer: geen Hiermee wordt het standaard EGA 8*14 karakterset in de fontram van de EGA of VGA kaart geladen. Automatisch wordt omgeschakeld naar 25 regels per scherm. Het kan nodig zijn om het tekstwindow te herdefini‰ren. */ { } void ega8x8() /* #57 Selecteer EGA 8*8 ROM font Invoer: geen Uitvoer: geen Hiermee wordt het standaard EGA 8*8 karakterset in de fontram van de EGA of VGA kaart geladen. Automatisch wordt omgeschakeld naar 43 regels per scherm voor EGA en 50 regels per scherm voor VGA. Het tekstwindow zal aange- past moeten worden. */ { } // vanaf hier de 3.xx uitbreidingen. /* #58 Schrijf grafisch venster naar disk Invoer: x-coördinaat links onder (1 word) y-coördinaat links onder (1 word) x-coördinaat rechts boven (1 word) y-coördinaat rechts boven (1 word) filehandle (1 byte) Uitvoer: geen Schrijft een grafisch window in een extended video mode naar file. De file moet reeds geopend zijn. De coordinaten van het window en de file handle worden als parameter opgegeven. De coördinaten gelden vanaf de logische oorsprong. Er wordt dus rekening gehouden met een verschoven oorsprong. Er wordt geen resultaat teruggegeven; het is dus niet bekend of alle data op de disk terecht zijn gekomen. Dit commando is hoofdzakelijk bedoeld om stukken van een grafisch scherm tijdelijk in een bestand op te slaan. Na beëindiging van het commando wordt de file niet automatisch afgesloten. #59 Lees grafisch venster van disk Invoer: x-coördinaat links onder (1 word) y-coördinaat links onder (1 word) filehandle (1 byte) Uitvoer: geen Een grafisch window dat met commando #58 naar file geschreven is kan hiermee teruggezet worden op het scherm. Dit hoeft niet op dezelfde plaats te zijn. De file moet al geopend zijn. Er wordt geen resultaat teruggemeld zodat niet bekend is of de data goed gelezen zijn. Na het inlezen wordt het bestand niet automatisch gesloten. #5A Diverse grafische functies SHAPES - leest een sub-commando nummer en voert vervolgens de functie uit. Bij deze functies wordt rekening gehouden met een verschoven grafische oorsprong en het huidige grafische venster. #5A subfunctie #0: teken een cirkel Invoer: x-coördinaat middelpunt (1 word) y-coördinaat middelpunt (1 word) straal (1 word) Uitvoer: geen In extended video mode wordt een cirkel getekend met het middelpunt op de opgegeven coördinaten en met de opgegeven straal. #5A subfunctie #1: teken een cirkel en vul deze Invoer: x-coördinaat middelpunt (1 word) y-coördinaat middelpunt (1 word) straal (1 word) Uitvoer: geen In extended video mode wordt een cirkel getekend met het middelpunt op de opgegeven coördinaten en met de opgegeven straal. Deze cirkel wordt opgevuld in de geldende voorgrondkleur. #5A subfunctie #2: teken een rechthoek Invoer: x-coördinaat linker benedenhoek (1 word) y-coördinaat rechter benedenhoek (1 word) x-coördinaat linker bovenhoek (1 word) y-coördinaat rechter bovenhoek (1 word) Uitvoer: geen In extended video mode wordt een rechthoek getekend tussen de opgegeven hoekpunten. #5A subfunctie #3: teken een rechthoek en vul deze Invoer: x-coördinaat linker benedenhoek (1 word) y-coördinaat rechter benedenhoek (1 word) x-coördinaat linker bovenhoek (1 word) y-coördinaat rechter bovenhoek (1 word) Uitvoer: geen In extended video mode wordt een rechthoek getekend tussen de opgegeven hoekpunten. Deze rechthoek wordt opgevuld in de geldende voorgrondkleur. #5A subfunctie #4: teken een driehoek Invoer: x en y-coördinaten eerste hoekpunt (2 words) x en y-coördinaten tweede hoekpunt (2 words) x en y-coördinaten derde hoekpunt (2 words) In extended video mode wordt een driehoek getekend tussen de opgegeven hoekpunten. #5A subfunctie #5: teken een driehoek en vul deze Invoer: x en y-coördinaten eerste hoekpunt (2 words) x en y-coördinaten tweede hoekpunt (2 words) x en y-coördinaten derde hoekpunt (2 words) In extended video mode wordt een driehoek getekend tussen de opgegeven hoekpunten. Deze driehoek wordt opgevuld in de geldende voorgrondkleur. #5A subfunctie #6: zet lijn patroon Invoer: bitpatroon van de lijn (1 word) Uitvoer: geen Om niet-aaneengesloten lijnen te tekenen kan met deze functie een 16-bits patroon opgegeven worden. #5A subfunctie #7: teken een rechte lijn Invoer: x-coördinaat beginpunt (1 word) y-coördinaat beginpunt (1 word) x-coördinaat eindpunt (1 word) y-coördinaat eindpunt (1 word) Uitvoer: geen In extended video mode wordt een lijn getekend tussen het opgegeven begin en eindpunt. Hierbij geldt dat een '1' in het lijn patroon (zie ook subfunctie #06) geplot wordt de geldende voorgrondkleur. Een '0' in het lijn patroon laat het pixel ongewijzigd. #5B Lees direct PC videogeheugen Invoer: offset adres videogeheugen (1 word) Uitvoer: data uit videogeheugen (1 byte) Deze call maakt het mogelijk om het PC videogeheugen direct uit te lezen, dus niet via het BIOS. Deze werkwijze is over het algemeen wat sneller. Bovendien worden hiermee ook systemen met twee monitoren ondersteund. #5C Schrijf direct PC videogeheugen Invoer: offset adres videogeheugen (1 word) data (1 byte) Uitvoer: geen Deze call maakt het mogelijk om direct naar het PC videogeheugen te schrijven, dus niet via het BIOS. Deze werkwijze is over het algemeen wat sneller. Bovendien worden hiermee ook systemen met twee monitoren ondersteund. #5D Verplaats datablok in PC videogeheugen Invoer: offset adres bron (1 word) offset adres bestemming (1 word) bloklengte (1 word) Uitvoer: geen Het datablok beginnende vanaf 'offset adres bron' met lengte 'bloklengte' wordt gekopieerd naar 'offset adres bestemming'. Hierme kunnen snel stukken tekst over het scherm verplaatst worden, data kan tussen verschillende schermpagina's gekopieerd worden of in twee-monitor systemen van de ene monitor naar de andere. #5E Diverse wachtfuncties Let op: de functies van commando #5E maken gebruik van BIOS INT 15H; deze is niet in een PC/XT ge‹mplementeerd! #5E subfunctie #0: Wacht gedurende ingestelde tijd Invoer: geen Uitvoer: dummy (1 byte) De PC wacht gedurende een van te voren opgegeven tijd. Na het verstijken van deze tijd wordt een dummy byte naar de Atom gestuurd om beide systemen te synchroniseren. De wachttijd kan met subfunctie #1 van commando #5E ingesteld worden. #5E subfunctie #1: Stel wachttijd in Invoer: tijd in microseconden (4 bytes) Uitvoer: geen Met deze functie wordt de wachttijd ingesteld voor de functies #0 en #2 van commando #5E. Het meest lage byte wordt als eerste overgestuurd. #5E subfunctie #2: Vlag zetten na wachttijd Invoer: geen Uitvoer: geen In de PC wordt een vlag gewist die na de opgegeven wachttijd gezet wordt. De wachttijd wordt ingesteld met commando #5E subfunctie #1. De status van deze vlag kan opgevraagd worden met commando #5E subfunctie #3. #5E subfunctie #3: Timer vlag uitlezen Invoer: geen Uitvoer: status van de vlag (1 byte) Als de wachtperiode, die met commando #5E subfunctie #2 gestart werd, verstreken is heeft bit 7 de waarde '1'. #5E subfunctie #4: 1/60 seconde wachten Invoer: geen Uitvoer: dummy byte (1 byte) Deze functie laat de PC 1/60 seconde wachten waarna een dummy byte naar de Atom gestuurd wordt om de twee systemen te synchroniseren. #5E subfunctie #5: 1/50 seconde wachten Invoer: geen Uitvoer: dummy byte (1 byte) Deze functie laat de PC 1/50 seconde wachten waarna een dummy byte naar de Atom gestuurd wordt om de twee systemen te synchroniseren. #5F Paint functies Deze functies kleuren gesloten vlakken in met gedefini‰rde patronen. Hierbij wordt rekening gehouden met een verschoven oorsprong en grafisch venster. Paint-patronen worden samen met de geplande sprites opgeslagen in het geheugen van de PC. In totaal zijn 64 patronen en sprites beschikbaar. Beiden hebben hetzelfde formaat, met afmetingen van 16*16 pixels. #5F subfunctie 0: vlak inkleuren in voorgrondkleur Invoer: grenskleur (1 byte) Uitvoer: geen Een vlak, ingesloten door lijnen in de grenskleur, wordt gevuld in de geldende voorgrondkleur. De grenskleur mag hetzelfde zijn als de huidige voorgrondkleur. #5F subfunctie n: vlak inkleuren volgens patroon n waarbij geldt: 1 < n < 64 Invoer: grenskleur (1 byte) Uitvoer: 0 -> geen fout (1 byte) n -> ongeldig patroon nummer Een vlak, ingesloten door lijnen in de grenskleur, wordt gevuld met het opgegeven patroon. De grenskleur mag hetzelfde zijn als de huidige voorgrondkleur. #5F subfunctie #FD: patroonfile laden van disk Invoer: pad+filenaam als ASCIIZ Uitvoer: error code (1 byte) Om een set met patronen te laden van disk dient dit commando gebruikt te worden. De filenaam mag vooraf gegaan worden door een drive en pad aanduiding. Wildcards zijn niet toegestaan. #5F subfunctie #FE: patroonfile schrijven naar disk Invoer: pad+filenaam als ASCIIZ Uitvoer: error code (1 byte) Een set met patronen wordt met dit commando op disk opgeslagen. De filenaam mag vooraf gegaan worden door een drive en pad aanduiding. Wildcards zijn niet toegestaan. #5F subfunctie #FF: patroon defini‰ren Invoer: patroonnummer (1 byte) patroon (256 bytes) Uitvoer: 0 -> geen fout (1 byte) n -> ongeldig patroon nummer Een patroon heeft de afmetingen van 16x16 bytes. Ieder byte bevat de kleurwaarde van ‚‚n pixel. Op deze manier kunnen dus maximaal 256 kleuren in een patroon verwerkt worden. De eerste 16 bytes vormen de bovenste rij van de patroon, de daaropvolgende 16 bytes de tweede rij enz. */ // vanaf hier de extra routines buiten de aanroep om. char *current_directory(char *path) /* */ { strcpy(path, "X:\\"); /* fill string with form of response: X:\ */ path[0] = 'A' + getdisk(); /* replace X with current drive letter */ getcurdir(0, path+3); /* fill rest of string with current directory */ return(path); } void read8b(unsigned char *tab) /* */ { int i; for (i=0; i<8; i++) tab[i]=READBYTEW(iobase); } void write8b(unsigned char *tab) /* */ { int i; for (i=0; i<8; i++) WRITEBYTE(iobase, tab[i]); } void pixel(int x, int y, int plot) /* */ { } void leesnaam() /* */ { unsigned int result; int i=0; do { szFilename[i] = READBYTEW(iobase); } while (szFilename[i++] !=0); // hier nog enige uitbreiding voor de : en de \ } void kopypage() { } void putwin() { } void getwin() { } void shapes() { unsigned char param; param= READBYTEW(iobase); switch (param) { case 0: // teken een circel break; case 1: // teken een filled circel break; case 2: // teken een rechthoek break; case 3: // teken een filled rechthoek break; case 4: // teken driehoek break; case 5: // teken een filled driehoek break; case 6: // zet lijn patroon break; case 7: // teken een rechte lijn break; case 8: // opvragen huidige schermkleur/attribuut break; default: // een nog onbekende paardemeter meegestuurd. break; } } void dir_vid_acc() { unsigned char param; param= READBYTEW(iobase); switch (param) { case 0: // lees direct video break; case 1: // schrijf direct video break; case 2: // blok kopieren break; case 0x5b: getreset(); break; case 0x5c: setreset(); break; case 0x5d: RESET(iobase); // reset the atom break; default: // foute boel aan parameters break; } } void dir_vid_rd() { unsigned char waarde; waarde = READBYTEW(iobase); // en nog veel meer } void getreset() { WRITEBYTE(iobase, resettype); } void setreset() { resettype = READBYTEW(iobase); } void wait() { unsigned char param; param= READBYTEW(iobase); switch (param) { case 0: // wacht een vooraf ingestelde tijd break; case 1: // stel wachttijd voor functies 0, 2 en 6 in break; case 2: // vlag zetten na wachttijd break; case 3: // vlag uitzetten break; case 4: // wacht 1/60e seconde wait160(); break; case 5: // wacht 1/50e seconde break; case 6: // laat toon horen gedurende de wachttijd break; default: // foute boel in parameters break; } } void paint() { unsigned char param; param = READBYTEW(iobase); switch (param) { case 0: break; case 1: break; case 2: break; case 3: break; case 4: break; case 5: break; default: break; } } void init0() { xco = 0 ; yco = 0 ; venster_xrb=32; venster_yrb=0; venster_ylo=16; venster_xlo=0; regels=0; bClear0 = TRUE; clear0w(); } void ascii_scan() /* #01 Keyboard scan Invoer: geen Uitvoer: scan code (1 byte) keyboard status (1 byte) De scan codes zijn gelijk aan de standaard PC- scancodes. */ { unsigned char status = 0; if (bShift) status |= 0x02; if (bKey != TRUE) { WRITEBYTE(iobase, status); } else { status |= 0x01; WRITEBYTE(iobase, status); WRITEBYTE(iobase, bascii); WRITEBYTE(iobase, bscan); } bKey = FALSE; }
terug.gif