SEAC: systeme d'exploitation "aproximativement complet"

les fonctions système sont appelé avec les interruptions 60h à 6Fh en assembleur ou avec leurs équivalent en C
si il y as plusieurs fonction disponible, le numéros de la fonction sera dans le registre al

int 60h termine la tache en cours
int 61h fonctions générales
int 62h force la commutation de tâche
int 63h fonctions d'interface
int 64h fonctions fichier
int 65h fonction de communication inter-tâche
int 66h fonctions port série et parallèles
int 68h fonctions périphériques usb

codes d'erreurs
codes de service

int 60h

termine la tache en cours (pas d'argument)

equivalent C

stop()

int 61h

fonctions générales
envoyer une commande au système
mettre en veille la tache
obtenir ID
obtenir commande
obtenir option dans commande (par n°)
obtenir option dans commande (par lettre)
écrire une ligne dans le journal
modifier descriptif de la tache
modifier taille d'un segment de la tache
lire la date et l'heure actuelle
déclarer son type de service
rechercher un service
lire compteur temps
obtenir message système
lire le journal
copier des données dans la zone de copier/coller
lire les données dans la zone de copier/coller
effacer la zone de copier/coller
lire le dossier de travail en cours
rechercher les taches que l'on as crée
convertir chaine décimale asciiz en entier 32bits
convertir chaine hexadécimale en entier 32bits
convertir entier 32bits en chaine décimale asciiz
convertir entier 32bits en chaine hexadécimale asciiz
convertir entier 16bits en chaine hexadécimale asciiz
convertir entier 8bits en chaine hexadécimale asciiz
convertir chaine asciiz en adresse Ethernet
convertir chaine asciiz en adresse ipv4
convertir chaine asciiz en adresse ipv6
convertir adresse Ethernet en chaine asciiz
convertir adresse ipv4 en chaine asciiz
convertir adresse ipv6 en chaine asciiz
convertir chaine utf8Z en GUID/UUID(en cours de dévellopement)
convertir GUID/UUID en chaine utf8Z(en cours de dévellopement)
convertir données base64 en données binaires
convertir données binaires en base64
convertir données binaires en base64url
convertire un compteur temp unix (unix timestamp) en date et heure
convertire une date et une heure en un compteur temp unix (unix timestamp)
calcul un crc16
calcul un crc32
décompresse une zone compressé par deflate
décompresse un fichier compressé par deflate

envoyer une commande au système

entrées:	al = 0 ds:edx = pointeur vers la commande a envoyer sous la forme d'une chaine utf8Z
sorties:	eax = code d'erreur
equivalent C	cmd()

mettre la tache en pause

entrées:	al = 1 ecx = durée de la pause divisé par 2.5ms
sorties:	eax = code d'erreur
equivalent C	delay()

obtenir l'ID de la tâche

entrées:	al = 2
sorties:	eax = code d'erreur bx = ID de la tache
equivalent C	id_tache()

lire la commande qui as appelé la tache

entrées:	al = 3 ds:edx = zone de 512 octet ou sera écrit la commande
sorties:	eax = code d'erreur
equivalent C	arg_tot()

lire un argument de la tache (par numéro)

entrées:	al = 4 ah = numéros de l'argument ds:edx = pointeur vers la zone mémoire ou copier l'argument cl = taille maximum (0=255)
sorties:	eax = code d'erreur
equivalent C	arg_num()

lire un argument de la tache (par lettre)

entrées:	al = 5 ah = lettre de l'argument ds:edx = pointeur vers la zone mémoire ou copier l'argument cl = taille maximum (0=255)
sorties:	eax = code d'erreur
equivalent C	arg_lettre()

ajouter du texte dans le journal systeme

entrées:	al = 6 ds:edx = pointeur vers le texte a écrire dans le journal sous la forme d'une chaine utf8Z
sorties:	eax = code d'erreur
equivalent C	printJ()

modifier le descripteur de la tâche

entrées:	al = 7 ds:edx = pointeur vers le texte a écrire dans le descripteur de tache sous la forme d'une chaine utf8Z
sorties:	eax = code d'erreur
equivalent C	printD()

modifier la taille d'un des segment de la tâche

entrées:	al = 8 dx = sélecteur du segment a modifier ecx = taille du segment souhaité
sorties:	eax = code d'erreur
equivalent C	changeT()

lire la date et l'heure

entrées:	al = 9
sorties:	bh = heure bl = minute si = seconde (en millième) dl = jour dh = mois cx = année
equivalent C	lireDH()

change le code de service de la tâche

entrées:	al = 10 ah = code service
sorties:	eax = code d'erreur
equivalent C	changeS()

recherche des services

entrées:	al = 11 ah = code service recherché ds:edx = pointeur vers la zone ou copier la table des services cl = nombre de service maximum dans la table
sorties:	eax = code d'erreur
equivalent C	rechercheS()

lire le compteur temps

entrées:	al = 12
sorties:	eax = 32bit de poids faible du compteur temps edx = 32bit de poids fort du compteur temps

lire message système et message d'erreur

entrées:	al = 13 ah = type de message (0 = système, 1 = erreur) ds:edx = pointeur vers la zone ou copier le message sous la forme d'une chaine utf8Z cl = numéros du message ch = taille maximum du message
sorties:	eax = codes d'erreurs

lire le journal système

entrées:	al = 14 es:edx = pointeur vers la zone ou copier le journal sous la forme d'une chaine utf8Z ecx = taille maximum du message
sorties:	eax = codes d'erreurs

copier des données dans le presse papier

entrées:	al = 15 es:edx = pointeur vers les données a copier ecx = taille des données a copier
sorties:	eax = codes d'erreurs

lire des données dans le presse papier

entrées:	al = 16 es:edx = pointeur vers l'endroit ou il faut écrire le presse papier ecx = taille des données a maximum que l'on peut écrire
sorties:	eax = codes d'erreurs

effacer le contenue du presse papier

entrées:	al = 17
sorties:	eax = codes d'erreurs

lire l'adresse du dossier de travail

entrées:	al = 18 es:edx = pointeur vers la zone de 512 octet ou copier l'adresse du dossier de travail sous la forme d'une chaine utf8Z
sorties:	eax = codes d'erreurs

recherche les taches que l'on as créer

entrées:	al = 11 ds:edx = pointeur vers la zone ou copier la table des id de tache cl = nombre de tache maximum dans la table
sorties:	eax = code d'erreur

convertir une chaine de caractère représentant un nombre décimal

entrées:	al = 100 ds:edx = pointeur vers la chaine a convertir
sorties:	eax = codes d'erreurs ecx = valeur de ce nombre

convertir une chaine de caractère représentant un nombre hexadécimal

entrées:	al = 101 ds:edx = pointeur vers la chaine a convertir
sorties:	eax = codes d'erreurs ecx = valeur de ce nombre

convertir un nombre 32bits en une chaine de caractère de sa représentation décimal

entrées:	al = 102 ecx = nombre ds:edx = pointeur vers une zone mémoire de 16 octet ou sera copié le résultat
sorties:	eax = codes d'erreurs

convertir un nombre 32bits en une chaine de caractère de sa représentation hexadécimal

entrées:	al = 103 ecx = nombre ds:edx = pointeur vers une zone mémoire de 16 octet ou sera copié le résultat
sorties:	eax = codes d'erreurs

convertir un nombre 16bits en une chaine de caractère de sa représentation hexadécimal

entrées:	al = 104 ecx = nombre ds:edx = pointeur vers une zone mémoire de 16 octet ou sera copié le résultat
sorties:	eax = codes d'erreurs

convertir un nombre 8bits en une chaine de caractère de sa représentation hexadécimal

entrées:	al = 105 ecx = nombre ds:edx = pointeur vers une zone mémoire de 16 octet ou sera copié le résultat
sorties:	eax = codes d'erreurs

convertir une chaine de caractère représentant une adresse ethernet en adresse ethernet codé comme dans une trame

entrées:	al = 108 ds:ecx = pointeur vers l'adresse a convertir ds:edx = pointeur vers une zone mémoire ou sera copié le résultat
sorties:	eax = codes d'erreurs

convertir une chaine de caractère représentant une adresse ipv4 en adresse ipv4 codé comme dans une trame

entrées:	al = 109 ds:ecx = pointeur vers l'adresse a convertir ds:edx = pointeur vers une zone mémoire ou sera copié le résultat
sorties:	eax = codes d'erreurs

convertir une chaine de caractère représentant une adresse ipv6 en adresse ipv6 codé comme dans une trame

entrées:	al = 110 ds:ecx = pointeur vers l'adresse a convertir ds:edx = pointeur vers une zone mémoire ou sera copié le résultat
sorties:	eax = codes d'erreurs

convertir adresse ethernet codé comme dans une trame en une chaine de caractère représentant une adresse ethernet

entrées:	al = 111 ds:ecx = pointeur vers la a zone ou ser copié le résultat ds:edx = pointeur vers la chaine de caractère a convertir
sorties:	eax = codes d'erreurs

convertir adresse ipv4 codé comme dans une trame en une chaine de caractère représentant une adresse ipv4

entrées:	al = 112 ds:ecx = pointeur vers la a zone ou ser copié le résultat ds:edx = pointeur vers la chaine de caractère a convertir
sorties:	eax = codes d'erreurs

convertir adresse ipv6 codé comme dans une trame en une chaine de caractère représentant une adresse ipv6

entrées:	al = 113 ds:ecx = pointeur vers la a zone ou ser copié le résultat ds:edx = pointeur vers la chaine de caractère a convertir
sorties:	eax = codes d'erreurs

convertir une chaine Base64(tout type) en binaire

entrées:	al = 116 ds:esi = chaine en base64 a convertir ecx = taille de la chaine ds:edi = pointeur vers une zone mémoire ou sera copié le résultat
sorties:	eax = codes d'erreurs

convertir donnée binaire en une chaine Base64 générale

entrées:	al = 117 ds:esi = données binaire a convertir ecx = taille des donnée ds:edi = pointeur vers une zone mémoire ou sera copié le résultat
sorties:	eax = codes d'erreurs

convertir donnée binaire en une chaine Base64 pour Url

entrées:	al = 118 ds:esi = données binaire a convertir ecx = taille des donnée ds:edi = pointeur vers une zone mémoire ou sera copié le résultat
sorties:	eax = codes d'erreurs

convertire un compteur temp unix (unix timestamp) en date et heure

entrées:	al = 119 ecx = lsb du comteur temp edx = msb du compteur temp
sorties:	eax = codes d'erreurs bh = heure bl = minute si = seconde (en millième) dl = jour dh = mois cx = année

convertire une date et une heure en un compteur temp unix (unix timestamp)

entrées:	al = 119 bh = heure bl = minute si = seconde (en millième) dl = jour dh = mois cx = année
sorties:	eax = codes d'erreurs ecx = lsb du comteur temp edx = msb du compteur temp

calcul un CRC16

entrées:	al = 150 ds:esi = début de la chaine ecx = Nb d'octet de la chaine bx = valeur initiale du CRC dx = "polynome"
sorties:	ax = valeur du CRC

calcul un CRC32

entrées:	al = 151 ds:esi = début de la chaine ecx = Nb d'octet de la chaine ebx = valeur initiale du CRC edx = "polynome"
sorties:	eax = valeur du CRC

décompression deflate

entrées:	al = 152 ds:esi = pointeur vers les données a décompresser es:edi = pointeur ver la zone ou seront décompressé les données
sorties:	eax = codes d'erreurs esi = nombre d'octet de la partie compressé edi = nombre d'octet de la partie decompressé

décompression de fichier deflate

entrées:	al = 153 edx = adresse dans le fichier ou se trouve les données compressé esi = n° du descripteur du fichier compressé edi = n° du descripteur du fichier ou seront décopressé les données
sorties:	eax = codes d'erreurs esi = nombre d'octet de la partie compressé edi = nombre d'octet de la partie decompressé

int 62h

force la commutation de tâche (pas d'argument)

equivalent C

raf()

int 63h

fonctions d'interface
création console
suppression console
obtenir information écran
change la console affiché
obtient le caractère+touche de la fifo de réception clavier
acquisition d'une chaine de caractère validé par entrée
demande la mise a jour complète de l'écran
demande la mise a jour partielle de l'écran
écrire une chaine utf8Z a une position défini
écrire une chaine a la position du curseur
définir la position du curseur
système de choix par menu
barre de progression mode texte
dessine un pixel a la position x y avec une couleur prédéterminé
dessiner un carré de couleur avec une couleur prédéterminé
dessiner un segment avec une couleur prédéterminé
dessiner un disque avec une couleur prédéterminé
écrire une chaine a la position x y
écrire une chaine a la position x y suivant une largeur maximale
écrire une image a la position x y
crée une image vide
lit les caractéristiques d'un fichier image
lit l'image d'un fichier image
déplace une image avec réadaptation de la taille
déplace un fragment d'image
insère une image dans une autre

création console

entrées:	al = 0 ah = options dx = selecteur du segment a uttiliser pour la console
sorties:	eax = codes d'erreurs

fermeture console

entrées:	al = 1
sorties:	aucunes sorties

lit les caractéristiques de l'écran

entrées:	al = 2 ds:edx = pointeur ou copier la table des informations (voir ci dessous)
sorties:	eax = codes d'erreurs

changement console affiché

entrées:	al = 3 dx = id de la tâche que l'on souhaite afficher
sorties:	eax = codes d'erreurs

lecture saisie clavier

entrées:	al = 5
sorties:	al = code de touche ou du bouton souris (valeurs F0h à FFh) ah = état des touche spéciales ebx = 0 ou position X si souris ecx = caractère associé a la touche ou position Y si souris

acquisition d'une chaine

entrées:	al = 6 ah = couleur ds:edx=adresse ou sera ecrit la chaine (avec chaine de pré remplissage obligatoire) ecx = nombre d'octet max
sorties:	al = code touche qui a validé la saisie

demande la mise a jour complète de l'écran

entrées:	al = 7
sorties:	eax = codes d'erreurs

demande la mise a jour partielle de l'écran

entrées:	al = 8 ebx = coordonnée X coin supérieur gauche ecx = coordonnée Y coin supérieur gauche esi = coordonné X coin inférieur droit edi = coordonné X coin inférieur droit
sorties:	eax = codes d'erreurs

écrire une chaine utf8Z a une position défini

entrées:	al = 10 ah = couleur ds:edx = pointeur vers chaine de caractère utf8z ebx = position en X ecx = position en Y
sorties:	eax = codes d'erreurs

écrire une chaine a la position du curseur

entrées:	al = 11 ah = couleur ds:edx = pointeur vers chaine de caractère utf8z
sorties:	eax = codes d'erreurs

définir la position du curseur

entrées:	al = 12 ebx = position en X ecx = position en Y
sorties:	eax = codes d'erreurs

système de choix par menu

entrées:	al = 13 bl = ligne preselectionné bh = couleur de base (3bits) cl = première ligne du menu ch = nombre de ligne
sorties:	eax = codes d'erreurs bl = ligne selectionné bh = touche qui as validé

barre de progression mode texte

entrées:	al = 14 esi = progression edi = total ebx = position X de la barre ecx = position Y de la barre edx = taille de la barre en nombre de caractère
sorties:	eax = codes d'erreurs

;?????????????????????????????

dessine un pixel a la position x y avec une couleur prédéterminé

entrées:	al = 21 ah = bit par pixel de la couleur bx = position X cx = position Y edx = couleur
sorties:	eax = codes d'erreurs

dessiner un carré de couleur avec une couleur prédéterminé

entrées:	al = 22 ah = bit par pixel de la couleur bx = coordonnée X coin supérieur gauche cx = coordonnée Y coin supérieur gauche si = coordonné X coin inférieur droit di = coordonné X coin inférieur droit edx = couleur
sorties:	eax = codes d'erreurs

dessiner un segment avec une couleur prédéterminé

entrées:	al = 23 ah = bit par pixel de la couleur bx = coordonnée X début cx = coordonnée Y début si = coordonné X fin di = coordonné X fin edx = couleur
sorties:	eax = codes d'erreurs

dessiner un disque avec une couleur prédéterminé

entrées:	al = 24 ah = bit par pixel de la couleur bx = position X cx = position Y edx = couleur esi=rayon du cercle
sorties:	eax = codes d'erreurs

écrire une chaine a la position x y

entrées:	al = 25 ah = couleur bx = position X cx = position Y ds:edx = pointeur vers la chaine utf8Z
sorties:	eax = codes d'erreurs

écrire une chaine a la position x y suivant une largeur maximale

entrées:	al = 26 ah = couleur bx = position X cx = position Y ds:edx = pointeur vers la chaine utf8Z esi = nombre de caractère max en largeur
sorties:	eax = codes d'erreurs

écrire une image a la position x y

entrées:	al = 27 bx = position X cx = position Y ds:edx = pointeur vers une image au format BMS
sorties:	eax = codes d'erreurs

crée une image vide

entrées:	al = 50 ah = nombre de bit par couleur ebx = largeur de l'image ecx = hauteur de l'image edx = couleur de l'image ds:edi=position de l'image
sorties:	eax = codes d'erreurs

lit les caractéristiques d'un fichier image

entrées:	al = 51 ebx = Id du fichier image
sorties:	eax = codes d'erreurs ebx = largeur de l'image ecx = hauteur de l'image edx = [24MSB = taille image au format BMS 8LSB = bit par pixel]

lit l'image d'un fichier image

entrées:	al = 52 ebx = Id du fichier image es:edi = adresse ou copier l'image
sorties:	eax = codes d'erreurs

déplace une image avec réadaptation de la taille

entrées:	al = 53 ds:esi = image d'origine ds:edi = image de sortie
sorties:	eax = codes d'erreurs

extrait un fragment d'image

entrées:	al = 54 ds:esi = image d'origine es:edi = image de sortie ebx = position x du fragment ecx = position y du fragment
sorties:	eax = codes d'erreurs

insère une image dans une autre

entrées:	al = 55 ds:esi = image d'origine ds:edi = image de sortie ebx = position x du fragment ecx = position y du fragment
sorties:	eax = codes d'erreurs

ouvrir fichier

entrées:	al = 0 ds:edx = chaine de caractère du nom du fichier a ouvrir ebx = numéros de dossier qui contient
sorties:	eax = codes d'erreurs bx=numéros du fichier
equivalent C	open_file()

fermer fichier

entrées:	al = 1 ebx = numéros du fichier a fermer
sorties:	eax = codes d'erreurs
equivalent C	close_file()

créer fichier

entrées:	al = 2 ds:edx = chaine de caractère du nom du fichier a créer ebx = numéros de dossier qui contiendra le fichier
sorties:	eax = codes d'erreurs bx=numéros du fichier
equivalent C	create_file()

supprimer fichier

entrées:	al = 3 ebx = numéros du fichier a fermer
sorties:	eax = codes d'erreurs
equivalent C	delete_file()

lit le fichier

entrées:	al = 4 es:edi = zone ou copier les données ebx = numéros du fichier ouvert edx = offset dans le fichier ecx = quantité a lire
sorties:	eax = codes d'erreurs
equivalent C	read_file()

ecrire dans le fichier

entrées:	al = 5 es:esi = adresse des données a copier ebx = numéros du fichier ouvert edx = offset dans le fichier ecx = quantité a ecrire
sorties:	eax = codes d'erreurs
equivalent C	write_file()

lit les attributs d'un fichier

entrées:	al = 6 ah = type d'attribut a lire(0=nom 1=taille fichier 2=attributs) ebx = numéros du fichier ds:edx=destination des données demandé
sorties:	eax = codes d'erreurs

ecrire les attributs d'un fichier

entrées:	al = 7 ah = type d'attribut a modifier(0=nom 1=taille fichier 2=attributs) ebx = numéros du fichier ds:edx = données demandé
sorties:	eax = codes d'erreurs

lire dans un secteur

entrées:	al = 8 ch = n° de disque cl = nombre de secteur a lire ebx = numéros de secteur es:edi = zone de destination
sorties:	eax = codes d'erreurs

ecrire dans un secteur

entrées:	al = 9 ch = n° de disque cl = nombre de secteur a lire ebx = numéros de secteur ds:esi = donnée a écrire
sorties:	eax = codes d'erreurs

lire les information d'un disque

entrées:	al = 10 ch = n° de disque es:edi = zone de destination
sorties:	eax = codes d'erreurs

met a jour la table des partition d'un disque

entrées:	al = 12 ch = n° de disque
sorties:	eax = codes d'erreurs

réserve espace pour fichier

entrées:	al = 15 ebx = numéros de descripteur fichier ecx = taille du fichier a reserver
sorties:	eax = codes d'erreurs

lit contenue répertoire

entrées:	al = 16 ds:edi = zt ou copier les données ecx = taille max edx = premier fichier a lire
sorties:	eax = codes d'erreurs ebx = nombre de fichier chargé dans la zt

lit disques disponible

entrées:	al = 17 ds:edx = pointeur ou copier le bitmap de 32 octet
sorties:	eax = codes d'erreurs

octet 0 à 15 partitions octet 16 a 19 usb octet 20 a 23 sata octet 24 a 28 reservé octet 29 = b0-b6 reservé b7= disquette octet 30 = cdrom (ide+sata) octet 31 = ata/atapi

lit nombre de secteur et taille secteur

entrées:	al = 18 ch = numéros de disque
sorties:	eax = codes d'erreurs ecx = taille des secteurs edx = msb nb de secteur ebx = lsb nb de secteur

int 65h

fonction de communication inter-tâche
ouverture canal
fermeture canal
tester changement descripteur
tester donnée disponible sur canaux
lire descripteur
ecrire descripteur
lire donnée sur canal
envoyer donnée sur canal
attendre changement descripteur sur canal
attendre donnée disponible sur canal
lire info sur canal

ouverture canal

entrées:	al = 0 bx = ID de la tache avec qui communiquer ecx = taille du descripteur edx = attribut canal esi = taille de la zone tampon d'envoie ou masque d'alignement mode 2 edi = taille de la zone tampon de reception
sorties:	eax = codes d'erreurs ebx = adresse de la zone dans la mémoire haute edx = adresse physique du descripteur

fermeture canal

entrées:	al = 1 ebx = adresse du canal dans la mémoire haute
sorties:	eax = codes d'erreurs

tester changement descripteur

entrées:	al = 2
sorties:	eax = codes d'erreurs ebx = adresse du canal dans la mémoire haute

tester donnée disponible sur canaux

entrées:	al = 3
sorties:	eax = codes d'erreurs ebx = adresse du canal dans la mémoire haute

lire descripteur

entrées:	al = 4 ebx = adresse du canal dans la mémoire haute ecx = quantité a lire esi = adresse dans la zone es:edi = desitination
sorties:	eax = codes d'erreurs

ecrire descripteur

entrées:	al = 5 ebx = adresse du canal dans la mémoire haute ecx = quantité a lire edi = adresse dans la zone ds:esi = origine des données
sorties:	eax = codes d'erreurs

lire donnée sur canal

entrées:	al = 6 ebx = adresse du canal dans la mémoire haute ecx = taille des donnée maximum a lire es:edi = zone ou seront écrite les données
sorties:	eax = code d'erreur ecx = taille des données lue

envoyer donnée sur canal

entrées:	al = 7 ebx = adresse du canal dans la mémoire haute ecx = taille des donnée a envoyer ds:esi = données a envoyer
sorties:	eax = code d'erreur ecx = taille des données écrite

attendre changement descripteur sur canal

entrées:	al = 8 ebx = adresse du canal dans la mémoire haute ecx = temps a attendre
sorties:	eax = code d'erreur

attendre donnée disponible sur canal

entrées:	al = 9 ebx = adresse du canal dans la mémoire haute ecx = temps a attendre
sorties:	eax = code d'erreur

lire info sur canal

entrées:	al = 10 ebx = adresse du canal dans la mémoire haute
sorties:	eax = code d'erreur bx = ID de la tache au bout du canal ecx = taille du descripteur edx = attribut canal esi = taille de la zone tampon d'envoie edi = taille de la zone tampon de reception ebp = données en attente de lecture

int 66h

fonctions port série et parallèles
envoyer octet
envoyer chaine
reçevoir octet
reçevoir chaine
lecture des bit de controle des ports
ecriture des bit de controle des ports
configurer port
reserver accès port
liberer accès port
changer la taille de la zt de reception

envoyer octet

entrées:	al = 0 ah = numéros de port cl = octet a envoyer
sorties:	eax = code d'erreur

numéros de port

0 à 7	Port COM 1 à COM 8
8 à 15	Port LPT 1 à LPT 8

envoyer chaine

entrées:	al = 1 ah = numéros de port es:esi = donnée a envoyer ecx = nombre d'octet a envoyer
sorties:	eax = code d'erreur

reçevoir octet

entrées:	al = 2 ah = numéros de port
sorties:	eax = code d'erreur cl = octet reçu

reçevoir chaine

entrées:	al = 3 ah = numéros de port es:edi = zone ou ecrire les données ecx = nombre d'octet a reçevoir maximum
sorties:	eax = code d'erreur

lecture des bit de controle des ports

entrées:	al = 4 ah = numéros de port
sorties:	eax = code d'erreur ecx = bit d'état

bit de controle pour port COM

0	DTR
1	RTS
2	CTS
3	DSR
4	RI
5	DCD/RLSD

bit de controle pour port LPT

0	saut de page
1	reset
2	selection périphérique
3	signal erreur
4	signal périphérique on line
5	signal plus de papier

ecriture des bit de controle des ports

entrées:	al = 5 ah = numéros de port ecx = bit d'état
sorties:	eax = code d'erreur

configurer port com

entrées:	al = 6 ah = numéros de port ecx = vitesse du port (max 115200bit/s) dl = attribut
sorties:	eax = code d'erreur

détail des attributs

0	0 = 7 bits par caractère 1 = 8bit par caractère
1	innutilisé
2	0 = 1 bit de stop, 1 = 2 bit de stop
3	0 = pas de bit de parité, 1 = présence d'un bit de parité
4	0 = parité impaire(odd), 1 = parité paire(even)

reserver accès port

entrées:	al = 7 ah = numéros de port
sorties:	eax = code d'erreur

liberer accès port

entrées:	al = 8 ah = numéros de port
sorties:	eax = code d'erreur

changer la taille de la zt de reception d'un port com

entrées:	al = 9 ah = numéros de port ecx = taille de la zone tampon de réception
sorties:	eax = code d'erreur

int 68h

fonctions périphériques usb
réservation périphérique
liberation acces périphérique
lecture descripteur
selection configuration actuelle
lecture configuration actuelle(en cours de dévellopement)
envoie commande brute(en cours de dévellopement)
envoie donnée bulk(en cours de dévellopement)
reception donnée bulk(en cours de dévellopement)
ouverture connexion isocrone vers terminaison(en cours de dévellopement)
ouverture connexion interruption vers terminaison(en cours de dévellopement)
fermeture connexion iso ou int(en cours de dévellopement)

réservation périphérique

entrées:	al = 0 bl = adresse du périphérique à reserver
sorties:	eax = code d'erreur

liberation acces périphérique

entrées:	al = 1 bl = adresse du périphérique à liberer
sorties:	eax = code d'erreur

lecture descripteur

entrées:	al = 2 bl = adresse du périphérique à liberer bh = terminaison dl = index du descripteur dh = type de descripteur
sorties:	eax = code d'erreur

selection configuration actuelle

entrées:	al = 3
sorties:	eax = code d'erreur

codes d'erreurs

code	signification
0	fonction exécute sans erreur
1	paramètre incorrecte
2	erreur de lecture
3	lecteur/disque/fichier non trouvé
4	erreur du système de fichier
5	erreur d'écriture
6	pas de réponse disque
7	disque occupé
8	fichier déjà ouvert
9	interdiction de lecture
10	interdiction d'ouverture
11	plus assez de mémoire
12	le fichier ouvert est un dossier
13	erreur d'origine inconnue (normalement jamais utilisé, sauf erreur)
14	nombre de couleur non reconnue
15	écran absent
16	zone tampon vide
17	zone tampon pleine
18	contrôleur ne répond pas
19	contrôleur absent
20	dossier non vide (dans le cas d'une suppression)
21	dossier non vide (dans le cas d'une suppression)
22	caractère interdit dans le nom de fichier
23	création de fichier impossible

codes de services

code	signification
0	aucun service
1	écran
2	camera
3	imprimante
4	scanner
5	son
6	réseau Ethernet
7	reseau wifi
8	service dns
9
10	aucun service
11 à 63	réservé pour les standard
64 à 255	utilisable

void stop()

termine la tache en cours

void cmd(char* commande)

Envoie une commande au systeme
commande = commande a envoyer au systeme

void delay(unsigned long temps)

attend
temps = temps à attendre en milliseconde

unsigned int id_tache()

Renvoie l'id de la tache

long arg_tot(char **string*)

lit la commande de la tache
string = zone de 512 octet ou sera recopiéla commande

long arg_num(char numero,char *string)

lit un argument par son numéros
numero = numéro de l'argument a lire
string = zone de 256 octet ou sera recopié l'argument

long arg_lettre(char lettre,char **string*)

lit un argument par sa lettre
lettre = numéro de l'argument a lire
string = zone de 256 octet ou sera recopié l'argument

void printJ(char **string*)

ecrit dans le journal systeme
string = chaine a ecrire dans le journal

void printD(char **string*)

change le descriptif de tache
string = chaine a ecrire dans le descripteur de tache

long changeT(long taille)

change la taille mémoire occupé par la tache
taille = taille souhaité

struct dateheure lireDH()

lire la date et l'heure
renvoie une structure d type dateheure

void changeS(unsigned char service)

change le service de la tache
service = code service fournis par l'application

unsigned long rechercheS(unsigned char service,unsigned int *table,unsigned char taille)

recherche une tache par son service
service = code service recherché
table = table d'int ou seront écrit la liste des id des tache
taille = nombre d'entrée maximum de la table

long compteur()

lit le compteur temps
=

void message_systeme(int num,char* chaine)

charge un message systeme
num = numéros du message a charger
chaine = zone de 256 octet ou seront copié le message systeme

void message_erreur(int num,char* chaine)

charge un message d'erreur
num = codes d'erreurs
chaine = zone de 256 octet ou seront copié le message d'erreur

void lire_journal(char* chaine,long taille)

lit le journal systeme
chaine = endroit ou copier le journal systeme
taille = nombre d'octet maximum du journal a lire

void ecrire_pp(char* chaine,long taille)

ecrire dans le presse papier
=

void lire_pp(char* chaine,long taille)

lit dans le presse papier
=

void effacer_pp()

efface le presse papier

void lire_dossier_travail(char* chaine)

lit le dossier de travail
chaine = espace de 512 octet ou sera copié le dosier de travail

void sous_taches(int* table,char nb)

liste les taches que l'on as créer
table = table ou seront recopié la liste de taches
nb = nombre maximum d'element de cette liste

long deci(char **chaine*)

convertit chaine décimal en nombre
chaine = chaine a convertir

long hexa(char **chaine*)

convertit chaine héxadécimal en nombre
chaine = chaine a convertir

void long2deci(long nombre,char **chaine*)

convertit un nombre en chaine décimal
nombre = nombre a convertir
chaine = chaine de 16 octets ou ecrire la conversion

void long2hexa(long nombre,char **chaine*)

convertit un nombre en chaine héxadécimal
nombre = nombre a convertir
chaine = chaine de 16 octets ou ecrire la conversion

void etherS2B(char **entrée*,char **sortie*)

convertit une adresse ethernet sous forme de chaine en forma binaire
entrée = adresse en format chaine
sortie = adresse en format binaire

void ipv4S2B(char **entree*,char **sortie*)

convertit une adresse ip V4 sous forme de chaine en forma binaire
entrée = adresse en format chaine
sortie = adresse en format binaire

ipv6S2B(char **entree*,char **sortie*)

convertit une adresse ip V6 sous forme de chaine en forma binaire
entrée = adresse en format chaine
sortie = adresse en format binaire

void etherB2S(char **entree*,char **sortie*)

convertit une adresse ethernet sous forme binaire en chaine
entrée = adresse en format binaire
sortie = adresse en format chaine

void ipv4B2S(char **entree*,char **sortie*)

convertit une adresse ip v4 sous forme binaire en chaine
entrée = adresse en format binaire
sortie = adresse en format chaine

void ipv6B2S(char **entree*,char **sortie*)

convertit une adresse ip v6 sous forme binaire en chaine
entrée = adresse en format binaire
sortie = adresse en format chaine

base64binaire(char **entree*,char **sortie, long taille*)

convertir une chaine codé en base64 en donnée binaire
=

void raf()

passe a la tache suivante

long open_file(char* nom)

ouvre un fichier, renvoie l'id du fichier ouvert ou -1 si cela as échoué
nom = nom du fichier

long close_file(long id)

ferme un fichier, renvoie le codes d'erreur de l'opération
id = id du fichier a fermer

long create_file(long nom)

crée un fichier, renvoie l'id du fichier ouvert ou -1 si cela as échoué
nom = nom du fichier

long delete_file(long id)

supprime un fichier, renvoie le codes d'erreur de l'opération
id = id du fichier a supprimer

long read_file(long id,long offset,long count,char* data)

lit dans un fichier, renvoie le codes d'erreur de l'opération
id = id du fichier a supprimer
offset = adresse dans le fichier
count = nombre d'octet
data = ou seront écrit les donnée lut

long write_file(long id,long offset,long count,char* data)

ecrit dans un fichier, renvoie le codes d'erreur de l'opération
id = id du fichier a supprimer
offset = adresse dans le fichier
count = nombre d'octet
data = donnée a ecrire

long taille_file(long id)

lit la taille d'un fichier, renvoie la taille du fichier ouvert ou -1 si cela as échoué
id = id du fichier a supprimer

long error_file()

donne le code de la dernière erreur lorsque les fonctions renvoie -1