Restaurer un fichier image sur une disquette [tasm]

Télécharger le projet
Commenter

Description

Ben vous saviez comment créer floppy.img d'une disquette ben maintenant vous pouvez réécrire cette image sur la disquette sans aucun souci, avec en prime par rapport à l'autre programme, un affichage de l'avancement de l'écriture sur le disque.
Rappel: à la moindre erreur le programme se stoppe et le format de disquette est toujours 3''1/2 et 1.44MO

Source / Exemple : 


;CODE ASM x86 COMPILE SOUS TASM 5.0

;------------------------SEGMENT DE DONNEES-------------------------
;-------------------------------------------------------------------
_data segment public
    Buffer  DB 512 Dup(0)       ;buffer correspondant à 1 secteur
    floppy  db 'FLOPPY.IMG',0
    err1    db 'Erreur du lecteur de disquette',10,13,'$'
    err2    db 'Erreur fichier',10,13,'$'
    err3    db 'Le fichier n existe pas',10,13,'$'
    piste   db 'Piste : $'
    secteur db 'Secteur : $'
    tete    db 'Tete : $'
    espace  db '   $'
    Handle  dw ?            ;pointeur sur fichier
_data ends
;-------------------------------------------------------------------

;------------------------SEGMENT DE CODE----------------------------
;-------------------------------------------------------------------
_code segment public
    assume cs:_code, ss:_stack

    erreur1:
        mov dx, Offset err1
        jmp erreur
    erreur2:
        mov dx, Offset err2
        jmp erreur
    erreur3:
	mov dx, Offset err3
	jmp erreur
    erreur:
        mov ah, 09h             ;fonction d'affichage 09 (via le dos)
        int 21h             ;interruption pour afficher err1 ou err2
        mov al, 01h             ;on mets dans al le code d'erreur 1
        jmp fin             
    fin:
        mov ah, 4Ch             ;fonction 4Ch de sortie de programme avec code d'erreur
        int 21h             ;interruption pour sortir

    start:

        ;synchronise le segment de donnée avec ds ainsi que es
            mov ax, _data
            mov ds, ax
            mov es, ax
        
        ;initialise le lecteur de disquette
            xor ah, ah      ;mets la fonction 00h dans ah pour "initialiser un disque"
            xor dl, dl      ;précise le numéro du disque à réinitialiser(00h pour le disquette A:)
            int 13h     ;par l'int 13 (lecteur de disquette)
            jc  erreur1     ;si CF=1 alors on affiche une erreur
        
        ;ouverture du fichier floppy.img
            mov ax, 3DA0h     ;fonction 3Dh pour ouvrir un fichier et A0 mode accès bloque le fichier
            mov dx, Offset floppy               ;@ du nom du fichier dans dx
            int 21h     ;interruption dos
            jc  erreur3     ;s'il le fichier n'existe pas alors on arrête
            mov [ds:Handle], ax ;mets dans la variable "Handle" le pointeur sur le fichier

        ;copie de la disquette (chaque boucle lit un secteur du fichier et l'écrit dans la disquette)

            ;initialisation des compteurs de la boucle (entre autres)
                mov al, 01h     ;on lit un seul secteur à chaque fois
                xor dx, dx      ;#lecteur disquette 0 + #face 0
                xor cx, cx      ;#piste 0 + #secteur 0
                inc cl      ;euh en fait #secteur 1 :-)
                mov bx, Offset Buffer;zone que l'on veut écrire

            ;debut de la copie          
                jmp faire

    tantque:
            inc cl
            cmp cl,19       ;il y a 18 secteurs par piste
            jne faire

            mov cl, 1
            inc dh
            cmp dh, 2       ;il y a 2 faces par disques
            jne faire
            
            xor dh, dh
            inc ch
            cmp ch, 80      ;il y a 80 pistes par face
            je  fintantque
            
    faire:      

	;lecture de 512 octets dans le fichier floppy.img
            push    ax          ;on sauvegarde quelques registres
            push    bx
            push    cx
            push    dx
                mov ah, 3Fh     ;fonction 40h pour lire dans un fichier
                mov bx, [ds:Handle] ;on précise dans bx le pointeur sur le fichier
                mov cx, 512     ;nombre d'octets à lire
                mov dx, Offset Buffer;@ du buffer où stoquer les 512 octets
                int 21h     ;interruption dos pour lire
                jc  erreur2     ;s'il s'est produit une erreur alors on arrête tout :)
            pop dx
            pop cx
            pop bx
            pop ax

        ;écriture du secteur de la disquette    
            mov ah, 02h     ;ATTENTION il faut mettre 02 avant CHAQUE écriture
            int 13h     ;en effet si la lecture est un succès, ah vaut alors 00h
            jc  erreur1
;/////////////////////////////////////////////AFFICHAGE FALCUTATIF/////////////////////////////
		;affichage si le secteur est 1
		cmp	cl, 1
		jne	nepasafficher
		push	ax bx cx dx

		mov	ah, 0Eh
		mov	al, 13
		int	10h
		mov	ah, 09h		
		mov	dx, Offset piste
		int	21h
		mov	al, ch
		call	AFFICHER_AL_DEC
		mov	dx, Offset espace
		int	21h
		mov	dx, Offset secteur
		int	21h
		mov	al, cl
		call	AFFICHER_AL_DEC
		mov	dx, Offset espace
		int	21h
		mov	dx, Offset tete
		int	21h
		pop	dx
		push	dx
		mov	al, dh
		call	AFFICHER_AL_DEC

		pop	dx cx bx ax
		nepasafficher:
;///////////////////////////////////////////////////////////////////////////////////////////

        jmp tantque

    fintantque:

            mov al, 00h
            jmp fin

;//////////////////////////////AFFICHER UN NOMBRE - FALCUTATIF/////////////////////////////////
AFFICHER_AL_DEC:		;affiche une valeur comprise entre 0 et 255 contenue dans AL
		push	cx bx ax
			mov	bl, 64h 			;100 en dec
			xor	cl, cl
			boucle1:
				xor	ah, ah
				div	bl
				;test pour ne pas afficher les zéros de devant
				or	cl, al
				cmp	cl, 0
				je	nepasafficherzero1				
					push	ax
						add	al, 30h		;48 en dec, cette addition permet d'obtenir un code ASCII
						mov	ah, 0Eh
						int	10h
					pop	ax
				nepasafficherzero1:
				cmp	bx, 1
				je	finboucle1
				push	ax
					xor	ah, ah
					mov	al, bl
					mov	bl, 0Ah		;pour diviser par 10 soit 0A
					div	bl
					mov	bl, al
				pop	ax
				mov	al, ah
				jmp	boucle1
	finboucle1:
		cmp	cl, 0
		jne	fin1
		mov	ax, 0E30h
		int	10h
		fin1:
		pop	ax bx cx
		ret
;//////////////////////////////////////////////////////////////////////////////////////////

_code ends
;--------------------------------------------------------------------

;------------------------SEGMENT DE LA PILE--------------------------
;--------------------------------------------------------------------
_stack segment stack
    db 100h dup (?)         ;déclare une pile de 256 octets
_stack ends
;--------------------------------------------------------------------

;------------------------SAUT AU DEBUT DU PROGRAMME------------------
    end start
;--------------------------------------------------------------------

Conclusion :


bon ben voilà deux petits programmes assez complets permettant de créer une image puis de la réécrire, pratique pour archiver ses disques, de plus ce format .img est standard vous pouvez par exemple créer l'image d'une disquette bootable et la réutiliser avec un simulateur de pc comme Bochs....
Manque peut-être une petite amélioration sympa passer en paramètre de la ligne de commande le nom du fichier que l'on souhaiterait créer ou écrire car floppy.img c'est quelque peu contraignant...
Télécharger le projet

Codes Sources

A voir également

S'inscrire maintenant

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.

Du même auteur (Ninkosen)