AVR-DOS File I-O ------------------------------------------------------------------------------------------ Liste des commandes AVR-DOS Files I/O ------------------------------------- BLOAD, BSAVE, CHDIR, CLEARATTR, DIR, DISKFREE, DISKSIZE, DriveCheck, DriveGetIdentity, DriveInit, DriveReset, DriveReadSector, DriveWriteSector, FILEATTR, FILEDATE, FILEDATETIME, FILELEN, FILETIME, FLUSH, FREEFILE, GETATTR, INITFILESYSTEM, KILL, LINE INPUT, LOC, LOF, MKDIR, NAME, RMDIR, SETATTR, WRITE ------------------------------------------------------------------------------------------ Autres commandes décrites dans le document AVR-DOS File System -------------------------------------------------------------- CLOSE, EOF, GET, INPUT, OPEN, PRINT, PUT, SEEK, ------------------------------------------------------------------------------------------ BLOAD ----- Action : Ecrit le contenu d'un fichier dans la SRAM. Syntaxe : BLoad sFileName, wSRAMPointer Remarques sFileName : (String) Nom du fichier à lire. wSRAMPointer : (Word) Adresse du premier octet à écrire sans la SRAM. Cette commande a besoin d'un espace mémoire sufisant. ------------------------------------------------------------------------------------------ BSAVE ----- Action : Sauvegarde le contenu de la SRAM dans un fichier Syntaxe : BSave sFileName, wSRAMPointer, wLength Remarques sFileName : (String) Nom du fichier a écrire. wSRAMPointer : (Word) Adresse du premier octet à lire dans la SRAM. wLength : (Word) Nombre d'octets à écrire dans le fichier. Un espace mémoire "fichier" libre est nécessaire pour l'exécution de cette commande. ------------------------------------------------------------------------------------------ CHDIR ----- Action : Cette commande éffectue un changement de répertoire. Syntaxe : CHDIR directory Remarques directory : (String) Le nom du répertoire destination La variable "directory" doit contenir un nom de répertoire existant sur le disque. Comme en DOS, il est possible d'utiliser ".." pour descendre d'un niveau dans l'arborescence des répertoires, le "\" permet de revenir à la racine. "directory" ne peut contenir un "chemin", un seul répertoire à la fois est autorisé. Il est possible d'ouvrir plusieurs fichiers dans des répertoires différents, et la commande CHDIR permet alors de passer d'un répertoire à un autre pour, par exemple, faire des copies de fichier. La commande "DIR", et la commande "OPEN" ne fonctionnent que dans le répertoire courant. La seule limite à l'ouverture de multiples répertoires est la mémoire. ------------------------------------------------------------------------------------------ CLEARATTR (new 2079) -------------------- Action : Remet à zéro les atributs de fichier. Syntaxe : CLEARATTR [sFile] , bFileAttribute Remarques sFile : (String) C'est le nom du ficher dont les attributs doivent-être éffacés. Ce nom de fichier ne peut contenir de "jockers" (*, ?, etc..) Le nom du chier peut-être ommis si le fichier a précédement été découvert par la fonction DIR() bFileAttribute : (Octet) Variable numérique qui contient les bits des attributs à éffacer. Cette fonction éfface les attributs DOS du fichier. Un fichier peut avoir de multiples attributs. Les attributs 8(Volume) et 15(Sub Directory) ne peuvent-être utilisés. Valeur - Attribut DOS 1 - Read Only (Lecture seule) 2 - Hidden (Caché) 4 - System File (Fichier système) 8 - Volume Label (Nom de volume) 16 - Sub Directory (Sous-répertoire) 32 - Archive (Archive) 64,128 - reserved (Non utilisés) Il est possible d'éffacer plusieurs attributs en une seule fois. Par exemple, si bFileAttribute vaut 3, les attributs éffacés seront (hidden + read only). Les bits d'attribut qui ne sont pas spécifiés dans la commande, restent inchangés. Pour activer des attributs, il faut utiliser la commande SETATTR. ------------------------------------------------------------------------------------------ DIR --- Action : Renvoie le premier nom de fichier correspondant au masque de fichier. Syntaxe : sFile = DIR(mask) sFile = DIR() Remarques SFile : (String) Sera le nom du fichier qui sera renvoyé par la commande DIR. Mask : (String) Masque fichier DOS standard. comme par exemple *.TXT ou *.*. La première utilisation de cette fonction doit avoir un masque. Les autres utilisation n'en n'ont pas besoin. A chaque utilisation de la fonction, le nom de fichier suivant sera renvoyé. S'il n'y a pas ou plus de fichier correspondant au masque, une chaîne vide est renvoyée. ------------------------------------------------------------------------------------------ DISKFREE -------- Action : Renvoie la place libre en kilo-octets (KB). Syntaxe : lFreeSize = DISKFREE() Remarques lFreeSize : (Long) Variable qui contient la place libre en kilo-octet. ------------------------------------------------------------------------------------------ DISKSIZE -------- Action : Renvoie la taille du disque en kilo-octets (KB). Syntaxe : lSize = DISKSIZE() Remarques lSize : (Long) Variable qui contient la taille du disque en kilo-octets. ------------------------------------------------------------------------------------------ DriveCheck ---------- Action : Teste si le disque (ou la carte) est prêt(e) à l'utilisation. Syntaxe : bErrorCode = DRIVECHECK() Remarques bErrorCode : (Byte) Variable octet qui contient la valeur de retour de la fonction. La fonction renvoie 0 si le disque est prêt. Dans les autres cas, la variable contient le code erreur (voir la liste des erreurs). Cette fonction peut-être utile avec l'utilisation de supports amovibles pour voir si le média est inséré et initialisé. ------------------------------------------------------------------------------------------ DriveGetIdentity ---------------- Action : Ecrit les "infos paramètre" de la carte ou du disque en SRAM. Syntaxe : bErrorCode = DRIVEGETIDENTIFY(wSRAMPointer) Remarques BErrorCode : (Byte) Variable qui reçoit le code d'erreur de la fonctio,. wSRAMPointer : (Word) Variable qui contient le pointeur en SRAM de l'emplacement où les informations du disque (ou de la carte) vont-être écrites. Cette fonction reçoit les "infos paramètre" (512 octets) du disque (ou de la carte) et les écrit dans la mémoire SRAM, à partir de l'emplacement mémoire dont l'adresse est donnée par la variable wSRAMPointer. Ces infos dépendent du matériel utilisé et contiennent par example le nombre de secteurs, la taille des secteurs, le numéro de série du disque (ou de la carte), etc ... Lorque tout se passe bien, le code erreur 0 est contenu dans la variable BErrorCode. Sinon, un code erreur est renvoyé (voir la liste des erreurs). ------------------------------------------------------------------------------------------ DriveInit --------- Action : Configure les pins de l'AVR raccordées au disque, au niveau hardware (PORTs et PINs) et initialise le disque (ou la carte). Syntaxe : bErrorCode = DRIVEINIT() Remarques BErrorCode : (Byte) Variable qui contient le code erreur renvoyé par la fonction après l'initialisation du disque. Si tout est OK, le code 0 est renvoyé, sinon, voir la liste des erreurs. ------------------------------------------------------------------------------------------ DriveReset ---------- Action : Initialise le disque (ou la carte). Syntaxe : bErrorCode = DRIVERESET() Remarques BErrorCode : (Byte) Variable qui contient le code erreur renvoyé par la fonction après l'initialisation du disque. Si tout est OK, le code 0 est renvoyé, sinon, voir la liste des erreurs. ------------------------------------------------------------------------------------------ DriveReadSector --------------- Action : Lit un secteur entier (512 octets) du disque (ou de la carte). Syntaxe : bErrorCode = DRIVEREADSECTOR(wSRAMPointer, lSectorNumber) Remarques bErrorCode : (Byte) Variable qui contient le code erreur renvoyé par la fonction. wSRAMPointer : (Word) Variable qui contient l'adresse du pointeur en SRAM de l'emplacement où les octets lus depuis le secteur vont-être écrits. lSectorNumber : (Long) Contient le n° du secteur à lire. Si tout est OK, le code 0 est renvoyé, sinon, voir la liste des erreurs. Attention : La variable wSRAMPointer ne contient pas l'adresse en SRAM du premier octet où le contenu du secteur sera écrit. Cet emplacement mémoire, contient l'adresse de l'emplacement mémoire où les 512 octets de données seront écrites. Cette manière de faire, permet de lire ou d'écrire l'espace-SRAM de puis ou vers le disque même s'il n'est pas déclaré dans les variables. Si vous connaissez l'adresse SRAM (venant du raport de compilation) d'un buffer, vous pouvez passer cette valeur directement, Sinon, vous pouvez obtenir l'adresse directement à partir de la fonction Bascom VARPTR (Voir l'exemple pour une meilleure compréhension). ------------------------------------------------------------------------------------------ DriveWriteSector ---------------- Action : Ecrit un secteur entier (512 octets) du disque (ou de la carte). Syntaxe : bErrorCode = DRIVEWRITESECTOR(wSRAMPointer, lSectorNumber) Remarques bErrorCode : (Byte) Variable qui contient le code erreur renvoyé par la fonction. wSRAMPointer : (Word) Variable qui contient l'adresse du pointeur en SRAM de l'emplacement où les octets lus depuis le secteur vont-être écrits. lSectorNumber : (Long) Contient le n° du secteur à lire. Si tout est OK, le code 0 est renvoyé, sinon, voir la liste des erreurs. Attention : La variable wSRAMPointer ne contient pas l'adresse en SRAM du premier octet où le contenu du secteur sera écrit. Cet emplacement mémoire, contient l'adresse de l'emplacement mémoire où les 512 octets de données seront écrites. Cette manière de faire, permet de lire ou d'écrire l'espace-SRAM de puis ou vers le disque m^me s'il n'est pas déclaré dans les variables. Si vous connaissez l'adresse SRAM (venant du raport de compilation) d'un buffer, vous pouvez passer cette valeur directement, Sinon, vous pouvez obtenir l'adresse directement à partir de la fonction Bascom VARPTR (Voir l'exemple pour une meilleure compréhension). ------------------------------------------------------------------------------------------ FILEATTR -------- Action : Renvoie le mode dans lequel le fichier est ouvert. Syntaxe : bFileAttribut = FILEATTR(bFileNumber) Remarques bFileAttribut : (Byte) Mode d'ouverture du ficier (voir la liste). bFileNumber : (Byte) Numéro di fichier ouvert. Valeur - Mode d'ouverture 1 - INPUT (Entrée) 2 - OUTPUT (Sortie) 8 - APPEND (Ajout) 32 - BINARY (Binaire) ------------------------------------------------------------------------------------------ FILEDATE -------- Action : Renvoie la date du fichier. Syntaxe : sDate = FILEDATE () sDate = FILEDATE (file) Remarques Sdate : (String) Variable texte qui contient la date. File : (String) Nom du fichier duquel la date est extraite. Cette fonction fonctionne avec n'importe-quel fichier dont vous donnez le nom. Si aucun nom n'est spécifié, c'est le dernier fichier sélectionné par la commande DIR() qui sera utilisé. ------------------------------------------------------------------------------------------ FILEDATETIME ------------ Action : Renvoie la date et l'heure du fichier. Syntaxe : Var = FILEDATETIME () Var = FILEDATETIME (file) Remarques Var : Variable qui contient la date et l'heure. File : (String) Nom du fichier duquel la date et l'heure sont extraites. Si Var est un string, elle doit-être dimensionnée à 17 octets de long. Si Var est une variable string indicée, la taille doit être de 6 ctets minimum. Si Var est numérique, c'est le format date/heure interne qui est utilisé. ------------------------------------------------------------------------------------------ FILELEN ------- Action : Renvoie la taille du fichier. Syntaxe : lSize = FILELEN () lSize = FILELEN (file) Remarques lSize : (Long) Contient la taille du fichier en octets. File : (String) Nom du ficheir pour lequel la taille est renvoyée. Si aucun nom n'est spécifié, c'est le dernier fichier sélectionné par la commande DIR() qui sera utilisé. ------------------------------------------------------------------------------------------ FILETIME -------- Action : Renvoie l'heure du fichier. Syntaxe : sTime = FILETIME () sTime = FILETIME (file) Remarques Stime : (String) Variable texte qui contient l'heure. File : (String) Nom du fichier duquel l'heure est extraite. Cette fonction fonctionne avec n'importe-quel fichier dont vous donnez le nom. Si aucun nom n'est spécifié, c'est le dernier fichier sélectionné par la commande DIR() qui sera utilisé. ------------------------------------------------------------------------------------------ FLUSH ----- Action : Ecrit le buffer courant d'un fichier sur le disque (ou la carte) et met le répertoire à jour. Syntaxe : FLUSH #bFileNumber FLUSH Remarques BFileNumber : (Byte) N° du fichier à traiter, comme par exemple #1 ou #ff. Cette fonction écrit sur le disque (ou la carte) toutes les données d'un fichier ouvert qui n'a pas encore été sauvé. Normalement, le disque (ou la carte) sont mis à jour, et le fichier est fermé ou déplacé vers un autre secteur. Si aucun n° de fichier n'est spécifié, Tous les fichiers ouverts vont-être "flushés". Cette fonction ne nécessite aucun buffer supplémentaire. Elle est utilisée pour être absolument certain que toutes les données sont écrites sur le disque. Cette fonction est utile par exemple dans les application "data logger" dont les données sont écrites de manière sporadique. En effet, une panne de courant fearit perdre les données contenues dans le buffer mémoire de l'AVR. ------------------------------------------------------------------------------------------ FREEFILE -------- Action : Renvoie un numéro de fichier libre. Syntaxe : bFileNumber = FREEFILE() Remarques bFileNumber : (Byte) contient le premier numéro de fichier libre. Les numéros de fichier envoyé, sont compris entre 128 et 255. Les numéros plus petit, sont réservés aux fichiers définits par l'utilisateur. ------------------------------------------------------------------------------------------ GETATTR ------- Action : Renvoie les attributs d'un fichier Syntaxe : bFileAttribut = GETATTR([sFile]) Remarques bFileAttribut : Numeric variable which is assigned with the file attribute. sFile : (String) C'est le nom du ficher dont les attributs doivent-être éffacés. Ce nom de fichier ne peut contenir de "jockers" (*, ?, etc..) Le nom du chier peut-être ommis si le fichier a précédement été découvert par la fonction DIR() Un fichier peut avoir de multiples attributs. Valeur - Attribut DOS 1 - Read Only (Lecture seule) 2 - Hidden (Caché) 4 - System File (Fichier système) 8 - Volume Label (Nom de volume) 16 - Sub Directory (Sous-répertoire) 32 - Archive (Archive) 64,128 - reserved (Non utilisés) Un fichier peut avoir plusiers attributs.Par exemple, si bFileAttribute vaut 3, les attributs seront (hidden + read only). ------------------------------------------------------------------------------------------ INITFILESYSTEM -------------- Action : Initialise le système de fichier. Syntaxe : bErrorCode = INITFILESYSTEM (bPartitionNumber) Remarques bErrorCode : (Byte) Erreur renvoyé par la fonction. Si pas d'erreur : 0. bPartitionNumber : (Byte) Numéro de la partition (normalement 1). Cette fonction lit le MBR (Master Boot Record) de la partition, et initialise le système de fichier. Cette fonction doit être utilisée avant tout autre fonction du sytème de fichier. ------------------------------------------------------------------------------------------ KILL ---- Action : Efface un fichier du disque (ou de la carte). Syntaxe : KILL sFileName Remarques sFileName : (String) Contient le nom du fichier à éffacer. Cette fonction ne supporte pas les jockers. Un fichier ouvert ne peut-être éffacé. L'erreur Dos peut-être vérifiée dans la variable gDOSError. ------------------------------------------------------------------------------------------ LINEINPUT --------- Action : Lit une ligne depuis un fichier ouvert. Syntaxe : LINEINPUT #bFileNumber, sLineText LINE_INPUT #bFileNumber, sLineText Remarques BfileNumber : (Byte) N° du fichier qui identifie un fichier ouvert. SlineText : (String) Variable qui reçoit la ligne suivante extraite du fichier. Cette fonction doit être utilsée sur des fichier déclarés en INPUT. Cette fonction ne fonctionne qu'avec des chaînes de charactères. Très utile pour travailler avec des fichiers texte. ------------------------------------------------------------------------------------------ LOC --- Action : Renvoie la position du dernier octet utilisé dans un fichier. Syntaxe : lLastReadWritten = LOC (#bFileNumber) Remarques bFileNumber : (Byte) N° du fichier qui identifie un fichier ouvert. lLastReadWritten : (Long) Reçoit la position du dernier ictet utilisé dans le fichier. Si une erreur arrive, la valeur 0 est renvoyée. L'erreur Dos peut-être vérifiée dans la variable gDOSError. Si le pointeur à été modifié par la commande SEEK, cette fonction ne pourra-être utilisée qu'après la commande lecture/écriture suivante. ------------------------------------------------------------------------------------------ LOF --- Action : Renvoie la longeur du fichier en octet. Syntaxe : lFileLength = LOF (#bFileNumber) Remarques bFileNumber : (Byte) N° du fichier qui identifie un fichier ouvert. LFileLength : (Long) Contient la longeur du fichier en octets. Si une erreur arrive, la valeur 0 est renvoyée. L'erreur Dos peut-être vérifiée dans la variable gDOSError. ------------------------------------------------------------------------------------------ MKDIR ----- Action : Commande de création d'un répertoire. Syntaxe : MKDIR directory Remarques MaKeDIRectory crée un répertoire dans le répertoie courant. Le nom du répertoire ne peut-être un périphérique comme COM1, LPT1, etc. Le nom du répertoire ne peut contenir de noms comme ".." or "\" qui sont réservés. Vous ne pouvez pas créer de répertoire en utilisant un chemin : MKDIR "test" ' OK MKDIR ".." ' Pas OK MKDIR "\" ' Pas OK MKDIR "test\abc" ' Pas OK MKDIR "test" : CHDIR "test" : MKDIR "abc" ' créera le répertoire "test\abc" ------------------------------------------------------------------------------------------ NAME ---- Action : Commande pour renommer un fichier ou un répertoire. Syntaxe : NAME old AS new Remarks old : (String) Ancien nom du fichier ou du répertoire. Ce nom doit exister dans le répertoire courant. new : (String) Nouveau nom du fichier ou du répertoire. Le répertoire en cours est utilisé. Les ancien et nouveau noms de fichier Both old and new must be valid file names and of the string data type. Constants are not allowed. ------------------------------------------------------------------------------------------ RMDIR ----- Action : Commande de suppression d'un répertoire. Syntaxe : RMDIR directory Remarks RMDIR (ReMove DIRectory) supprime le répertoire désigné dans la commande. Le répertoire doit exister. L'utilisation d'un chemin est interdite. Le répertoire doit être vide pour pouvoir l'éffacer. ------------------------------------------------------------------------------------------ SETATTR (new 2079) ------------------ Action : Active les atributs de fichier. Syntaxe : SETATTR [sFile ,] bFileAttribute Remarques sFile : (String) C'est le nom du ficher dont les attributs doivent-être activés. Ce nom de fichier ne peut contenir de "jockers" (*, ?, etc..) Le nom du chier peut-être ommis si le fichier a précédement été découvert par la fonction DIR() bFileAttribute : (Octet) Variable numérique qui contient les bits des attributs à activer. Cette fonction active les attributs DOS du fichier. Un fichier peut avoir de multiples attributs. Les attributs 8(Volume) et 15(Sub Directory) ne peuvent-être utilisés. Valeur - Attribut DOS 1 - Read Only (Lecture seule) 2 - Hidden (Caché) 4 - System File (Fichier système) 8 - Volume Label (Nom de volume) 16 - Sub Directory (Sous-répertoire) 32 - Archive (Archive) 64,128 - reserved (Non utilisés) Il est possible d'activer plusieurs attributs en une seule fois. Par exemple, si bFileAttribute vaut 3, les attributs éffacés seront (hidden + read only). Les bits d'attribut qui ne sont pas spécifiés dans la commande, restent inchangés. Pour éffacer des attributs, il faut utiliser la commande CLEARATTR. ------------------------------------------------------------------------------------------ WRITE ----- Action : Ecrit des données dans un fichier séquentiel. Syntaxe : WRITE #ch , data [,data1] Remarques Ch : Variable contenant le N° du canal qui identifie un fichier ouvert. Cela peut-être une variable ou une constante. Data , data1 : Variables qui contiennent les données à écrire dans le fichier. Lorsque vous évrivez une valeur de variable, vous n'écrivez pas sa valeur binaire, mais bien sa représentation en ASCII. Le fichier créé est en fait un fichier texte lisible avec un éditeur. L'instruction qui écrit des valeurs ninaires est PUT. Le fichier peut alors contenir des charactères illisibles. Si des chaînes de charactères sont utilisées, elles doivent-être délimitées par des guillemets ("). Si l'on utilise plusieurs valeurs, elles doivent-être séparées par des virgules (,). Voici un exemple : Dim S as String * 10 , W as Word S="hello" : W = 100 OPEN "test.txt" For OUTPUT as #1 WRITE #1, S , W CLOSE #1 Le contenu du fichier sera : ["hello",100]