[THOMSON] ARDDRIVE
Modérateurs : Papy.G, fneck, Carl
-
- Messages : 7924
- Inscription : 18 sept. 2010 12:08
- Localisation : Brest et parfois les Flandres
Re: [THOMSON] ARDDRIVE
On sent bien la satire... mais est-ce à but humoristique? J'ai comme un doute. Surtout que Nicolho n'a visiblement pas compris que la connexion sur le port d'extension permet aussi d'avoir accès à la ROM disk sans avoir besoin de bricoler une extension nanoreseau. [supp modo: afin d'éviter les polémiques]
Avant d'avoir des jugements définitifs sur ce qu'il aurait fallu faire etc, il faut bien comprendre l'évolution du principe de connexion d'un thomson à un support SD. Ca n'est pas un truc trivial, mais quelque chose qui s'est élaboré sur plusieurs années à force de travail et recherches perso de la part de Daniel. Tout est rapporté sur system-cfg, mais pour épargner une fouille archéologique dans les archives du site, je vais tenter un résumé simplifié. [EDIT] ah zut, ca reste gros quand même même si c'est bien plus petit que mon résumé précédent .
Au départ (MO5SD) il fallait brancher le support SD sur les pinoches du lecteur K7 mo. La lecture se faisait alors en série (les cartes SD ne connaissent que ca pour ainsi dire) sans avoir accès au système de fichier de la carte SD Il fallait utiliser un outil windows pour trouver les données LBA à entrer coté MO pour charger les bonnes données.
Cette solution de marche pas pour les machines TO, et donc Daniel a adapté le système pour accéder à la SD via les pinoches d'une des manettes de jeu bloquée pour l'occasion (TO8SD, puis SDMOTO). Ensuite Daniel a eu l'idée de reprogrammer l'extension nano-reseau avec une ROM disk adaptée à ce système. Il n'y avait plus besoin du programme windows. C'était une grande avancée, mais une manette de jeu était toujours inutilisable et il fallait aussi se dégoter une extension nano-reseau à modifier. La carte SD continue, elle, toujours à être lue en mode série (les cartes SD ne font que cela pour ainsi dire).
Plus tard, Daniel ayant réalisé qu'il pouvait remplacer le boitier nanoreseau par une carte d'extension (CS91-280) fournissant la ROM-Disk. Cool, il n'était plus besoin de partir à la chasse au boitier nano-reseau devenu rare et cher. La carte SD est quant à elle toujours branchée sur un port manette avec l'extension SDMOTO. Elle est aussi toujours lue de façon sérielle (les cartes SD ne savent faire que cela pour ainsi dire...)
Enfin, ayant progressé dans la fabrication de cartes d'extension pour les machines Thomson, Daniel a réalisé une nouvelle carte d'extension (SDDrive) combinant la fourniture de la ROM-Disk ainsi que d'une logique simple pour lire la carte SD qui est maintenant directement connectée dessus. Outre le fait que cela libère enfin les ports manette (et que ca marche même sans elles), la logique dédiée à la lecture/écriture de la carte SD permet un accès plus rapide coté thomson. Cette solution est la plus rapide de toutes. C'est la solution ultra-compacte ultime.
Et la carte SD? en bien elle est toujours lue en série, bit après bit car les cartes SD ne savent ........... faire que cela pour ainsi dire (ca va, il y en a qui suivent .)
Un gars qui jugerait un peu vite le travail accompli rien dirait alors: ben pourquoi alors qu'on a fait une carte dédiée ne peut on pas "ajouter un truc" pour lire les données de la carte SD octet par octet plutôt que bit par bit? Parce que ce "truc" là est loin d'être trivial. Daniel a essayé un arduino et ca n'a pas été simple.
Pourquoi pas simple? Il faut relire le fil SDAnim7 disponible sur ce site, mais de ce que j'en retiens il faut comprendre que outre le fait que carte SD ne délivre ses secteurs que bit par bit (en simplifiant), la lecture série par le thomson a l'avantage que c'est ce dernier qui génère l'horloge à la carte SD ce qui rend le protocole de communication plutôt propre, robuste et simple sans nécessiter de timing strict.
En revanche si on veut que le thomson lise octet par octet, il faut que la carte d'extension aille, d'elle-même, générer les 8 top d'horloge tout seul, collecter et assembler les bits et fournir le résultat sur le bus de donnée thomson lorsque ce dernier demande un nouvel octet et recommencer l'opération plus tard dans un timing imprécis quand le thomson redemandera un nouvel l'octet.
Ce n'est pas tellement l'assemblage ou la collecte des bits qui est délicat, mais le fait qu'il faille faire tout cela très précisément et rapidement au bon moment en dépit des aléas coté Thomson ou SD (le changement de secteur ne se fait pas en temps constant par exemple). Bref: la synchronisation de l'ensemble est assez délicate. Malgré la puissance cpu nettement plus grande coté arduino que coté thomson, l'arduino a parfois du mal à respecter les timings demandés par le thomson.
Au final, à force de travail nettement plus long que les autre (et l'utilisation d'analyseur logique pour comprendre les plantes mystérieuses si je me souviens bien), Daniel a réussi à faire sortir de l'arduino les données octets par octet de la carte SD en utilisant un couple programme de lecture vidéo au timing très strict coté thomson et programme de lecture de carte SD coté arduino. C'est le projet SDAnim7.
Autant cela marche bien pour du streaming audio/vidéo à 120ko/sec, autant l'experience a montré qu'il sera difficile de faire un truc plus variable comme une ROM-Disk (projet ARDrive) tant est grande la variété des commandes et timings à prendre en compte. Pour rappel: il faut synchroniser précisément l'arduino et le thomson pour toutes les opérations prévues dans le ROM-Disk. Ceci explique la difficulté du projet de ce fil.
Voilà je pense avoir résumé l'historique amenant à ce sujet, en espérant que les gens qui jugent, sans expérience, que ce n'est pas la bonne solution, qu'il aurait fallu faire autrement, que le projet piétine pour telle ou telle raison, voient que le problème n'est pas aussi simple qu'on l'imagine naïvement.
Avant d'avoir des jugements définitifs sur ce qu'il aurait fallu faire etc, il faut bien comprendre l'évolution du principe de connexion d'un thomson à un support SD. Ca n'est pas un truc trivial, mais quelque chose qui s'est élaboré sur plusieurs années à force de travail et recherches perso de la part de Daniel. Tout est rapporté sur system-cfg, mais pour épargner une fouille archéologique dans les archives du site, je vais tenter un résumé simplifié. [EDIT] ah zut, ca reste gros quand même même si c'est bien plus petit que mon résumé précédent .
Au départ (MO5SD) il fallait brancher le support SD sur les pinoches du lecteur K7 mo. La lecture se faisait alors en série (les cartes SD ne connaissent que ca pour ainsi dire) sans avoir accès au système de fichier de la carte SD Il fallait utiliser un outil windows pour trouver les données LBA à entrer coté MO pour charger les bonnes données.
Cette solution de marche pas pour les machines TO, et donc Daniel a adapté le système pour accéder à la SD via les pinoches d'une des manettes de jeu bloquée pour l'occasion (TO8SD, puis SDMOTO). Ensuite Daniel a eu l'idée de reprogrammer l'extension nano-reseau avec une ROM disk adaptée à ce système. Il n'y avait plus besoin du programme windows. C'était une grande avancée, mais une manette de jeu était toujours inutilisable et il fallait aussi se dégoter une extension nano-reseau à modifier. La carte SD continue, elle, toujours à être lue en mode série (les cartes SD ne font que cela pour ainsi dire).
Plus tard, Daniel ayant réalisé qu'il pouvait remplacer le boitier nanoreseau par une carte d'extension (CS91-280) fournissant la ROM-Disk. Cool, il n'était plus besoin de partir à la chasse au boitier nano-reseau devenu rare et cher. La carte SD est quant à elle toujours branchée sur un port manette avec l'extension SDMOTO. Elle est aussi toujours lue de façon sérielle (les cartes SD ne savent faire que cela pour ainsi dire...)
Enfin, ayant progressé dans la fabrication de cartes d'extension pour les machines Thomson, Daniel a réalisé une nouvelle carte d'extension (SDDrive) combinant la fourniture de la ROM-Disk ainsi que d'une logique simple pour lire la carte SD qui est maintenant directement connectée dessus. Outre le fait que cela libère enfin les ports manette (et que ca marche même sans elles), la logique dédiée à la lecture/écriture de la carte SD permet un accès plus rapide coté thomson. Cette solution est la plus rapide de toutes. C'est la solution ultra-compacte ultime.
Et la carte SD? en bien elle est toujours lue en série, bit après bit car les cartes SD ne savent ........... faire que cela pour ainsi dire (ca va, il y en a qui suivent .)
Un gars qui jugerait un peu vite le travail accompli rien dirait alors: ben pourquoi alors qu'on a fait une carte dédiée ne peut on pas "ajouter un truc" pour lire les données de la carte SD octet par octet plutôt que bit par bit? Parce que ce "truc" là est loin d'être trivial. Daniel a essayé un arduino et ca n'a pas été simple.
Pourquoi pas simple? Il faut relire le fil SDAnim7 disponible sur ce site, mais de ce que j'en retiens il faut comprendre que outre le fait que carte SD ne délivre ses secteurs que bit par bit (en simplifiant), la lecture série par le thomson a l'avantage que c'est ce dernier qui génère l'horloge à la carte SD ce qui rend le protocole de communication plutôt propre, robuste et simple sans nécessiter de timing strict.
En revanche si on veut que le thomson lise octet par octet, il faut que la carte d'extension aille, d'elle-même, générer les 8 top d'horloge tout seul, collecter et assembler les bits et fournir le résultat sur le bus de donnée thomson lorsque ce dernier demande un nouvel octet et recommencer l'opération plus tard dans un timing imprécis quand le thomson redemandera un nouvel l'octet.
Ce n'est pas tellement l'assemblage ou la collecte des bits qui est délicat, mais le fait qu'il faille faire tout cela très précisément et rapidement au bon moment en dépit des aléas coté Thomson ou SD (le changement de secteur ne se fait pas en temps constant par exemple). Bref: la synchronisation de l'ensemble est assez délicate. Malgré la puissance cpu nettement plus grande coté arduino que coté thomson, l'arduino a parfois du mal à respecter les timings demandés par le thomson.
Au final, à force de travail nettement plus long que les autre (et l'utilisation d'analyseur logique pour comprendre les plantes mystérieuses si je me souviens bien), Daniel a réussi à faire sortir de l'arduino les données octets par octet de la carte SD en utilisant un couple programme de lecture vidéo au timing très strict coté thomson et programme de lecture de carte SD coté arduino. C'est le projet SDAnim7.
Autant cela marche bien pour du streaming audio/vidéo à 120ko/sec, autant l'experience a montré qu'il sera difficile de faire un truc plus variable comme une ROM-Disk (projet ARDrive) tant est grande la variété des commandes et timings à prendre en compte. Pour rappel: il faut synchroniser précisément l'arduino et le thomson pour toutes les opérations prévues dans le ROM-Disk. Ceci explique la difficulté du projet de ce fil.
Voilà je pense avoir résumé l'historique amenant à ce sujet, en espérant que les gens qui jugent, sans expérience, que ce n'est pas la bonne solution, qu'il aurait fallu faire autrement, que le projet piétine pour telle ou telle raison, voient que le problème n'est pas aussi simple qu'on l'imagine naïvement.
Samuel.
A500 Vampire V2+ ^8^, A1200 (030@50mhz/fpu/64mb/cf 8go),
A500 GVP530(MMU/FPU) h.s., R-Pi, TO9, TO8D, TO8.Démos
A500 Vampire V2+ ^8^, A1200 (030@50mhz/fpu/64mb/cf 8go),
A500 GVP530(MMU/FPU) h.s., R-Pi, TO9, TO8D, TO8.Démos
Re: [THOMSON] ARDDRIVE
Merci __sam__, je n'aurais pas mieux résumé.
Juste un petit ajout pour souligner une (r)évolution importante du projet : au départ, pour utiliser les interfaces MO5SD et TO8SD, puis SDMO et SDMOTO, un programme était chargé dans l'ordinateur pour initialiser la carte SD et lire ou écrire des secteurs physiques. Il fallait donc un lecteur de cassette, ou un lecteur de disquette, ou taper le programme à la main (bon courage).
Comme l'a écrit __sam__, l'utilisation d'une EPROM dans le contrôleur nanoréseau, puis dans les contrôleurs CS91-280 et SDDRIVE, permet d'éviter le chargement de ce programme, mais pas seulement : l'EPROM contient aussi un contrôleur de fichier .sd. Il se comporte comme un contrôleur de disquette Thomson et permet d'utiliser toutes les routines d'accès du système : formatage, lecture/écriture d'un secteur, backup, et toutes les fonctions du "scratchdos" pour le traitement des fichiers. Toutes les applications sur disquette de la logithèque Thomson peuvent être transformées en fichier .sd.
Pour résumer, les systèmes CS91-280 et SDDRIVE remplacent à la fois deux lecteurs de disquette 3"1/2 et un contrôleur de disquette Thomson. Ce deuxième point est particulièrement intéressant pour les machines sans contrôleur intégré (TO7, TO7/70, MO5 et MO6). En voyant le prix sur ebay d'un contrôleur CD90-351 les utilisateurs de mes contrôleurs les apprécieront encore plus.
Je ne suis pas électronicien, c'est pourquoi je suis resté simple, avec uniquement des circuits TTL et une EPROM 2732. Il y a d'autres solutions, à base d'électronique moderne, rapide, performante, comme les FPGA ou le Raspberry Pi. C'est une autre approche, totalement différente. J'espère voir bientôt des périphériques Thomson de ce type. Les miens sont beaucoup plus limités, mais ils utilisent la même technologie que les ordinateurs des années 1980. Observez bien le schéma de SDDRIVE, vous verrez que tous les composants (sauf la carte microSD) existaient déjà en 1984.
Juste un petit ajout pour souligner une (r)évolution importante du projet : au départ, pour utiliser les interfaces MO5SD et TO8SD, puis SDMO et SDMOTO, un programme était chargé dans l'ordinateur pour initialiser la carte SD et lire ou écrire des secteurs physiques. Il fallait donc un lecteur de cassette, ou un lecteur de disquette, ou taper le programme à la main (bon courage).
Comme l'a écrit __sam__, l'utilisation d'une EPROM dans le contrôleur nanoréseau, puis dans les contrôleurs CS91-280 et SDDRIVE, permet d'éviter le chargement de ce programme, mais pas seulement : l'EPROM contient aussi un contrôleur de fichier .sd. Il se comporte comme un contrôleur de disquette Thomson et permet d'utiliser toutes les routines d'accès du système : formatage, lecture/écriture d'un secteur, backup, et toutes les fonctions du "scratchdos" pour le traitement des fichiers. Toutes les applications sur disquette de la logithèque Thomson peuvent être transformées en fichier .sd.
Pour résumer, les systèmes CS91-280 et SDDRIVE remplacent à la fois deux lecteurs de disquette 3"1/2 et un contrôleur de disquette Thomson. Ce deuxième point est particulièrement intéressant pour les machines sans contrôleur intégré (TO7, TO7/70, MO5 et MO6). En voyant le prix sur ebay d'un contrôleur CD90-351 les utilisateurs de mes contrôleurs les apprécieront encore plus.
Je ne suis pas électronicien, c'est pourquoi je suis resté simple, avec uniquement des circuits TTL et une EPROM 2732. Il y a d'autres solutions, à base d'électronique moderne, rapide, performante, comme les FPGA ou le Raspberry Pi. C'est une autre approche, totalement différente. J'espère voir bientôt des périphériques Thomson de ce type. Les miens sont beaucoup plus limités, mais ils utilisent la même technologie que les ordinateurs des années 1980. Observez bien le schéma de SDDRIVE, vous verrez que tous les composants (sauf la carte microSD) existaient déjà en 1984.
Daniel
L'obstacle augmente mon ardeur.
L'obstacle augmente mon ardeur.
Re: [THOMSON] ARDDRIVE
Pour revenir au projet, nos débats ont étés utiles, en particulier la suggestion d'utiliser un convertisseur SD-->CF ou SD-->IDE.
Je viens de commander le convertisseur SD-->IDE pour le tester. Il n'est pas impossible qu'ARDDRIVE se transforme en IDEDRIVE.
D'ici là un RPIDRIVE sera probablement disponible, les utilisateurs pourront choisir
Je viens de commander le convertisseur SD-->IDE pour le tester. Il n'est pas impossible qu'ARDDRIVE se transforme en IDEDRIVE.
D'ici là un RPIDRIVE sera probablement disponible, les utilisateurs pourront choisir
Daniel
L'obstacle augmente mon ardeur.
L'obstacle augmente mon ardeur.
Re: [THOMSON] ARDDRIVE
[supp modo: propos déplacés]
Re: [THOMSON] ARDDRIVE
Pour l'instant, vous l'avez compris, le projet ARDDRIVE est en pause, au moins de mon côté.
En revanche, si quelqu'un veut le reprendre, je donnerai tous les éléments nécessaires.
Pour commencer le programme de l'EPROM :
En revanche, si quelqu'un veut le reprendre, je donnerai tous les éléments nécessaires.
Pour commencer le programme de l'EPROM :
Code : Tout sélectionner
SETLI 132
/**************************************************\
* A R D D R I V E _ C O N T R O L *
* (c) 2019 - Daniel Coulom *
* http://dcmoto.free.fr/ *
* http://forum.system-cfg.com/ *
*--------------------------------------------------*
* Ce code est distribue gratuitement dans l'espoir *
* qu'il sera utile, mais sans aucune garantie et *
* sans engager la responsabilité de l'auteur. *
* Vous pouvez l' utiliser, le modifier et le *
* diffuser librement, en conservant cette licence *
* et les références de l'auteur dans toutes les *
* copies. L'exploitation commerciale est interdite.*
\**************************************************/
* Ce programme emule un controleur de disquette
* Thomson accedant a une image au format .sd par
* l'intermediaire d'un Arduino
* Il est destine a être charge dans l'EPROM du
* controleur ARDDRIVE.
* Auteur : Daniel Coulom, d'après la rom CD90-640
* Calcul du LBA avec le code de Samuel Devulder
* Optimisation lecture octet par Samuel Devulder
*
* Utilisation des deux ports manettes connectes
* au broches D0-D9 de l'Arduino
*
/**************************************************\
* Version 2019.04.11 *
* (reporter la version en fin de programme) *
\**************************************************/
* Historique
* 2019.04.11 correction de petites anomalies
* 2019.04.09 mise a jour d'apres SDDRIVE_CONTROL
* 2018.05.09 fonctions pour initialiser lecture/ecriture
* 2018.04.25 premiere version issue de CS91280-control
*------------------------------------------------------
* VECTEURS EN RAM
*------------------------------------------------------
DK_OPC EQU $6048 code commande controleur disquette
DK_DRV EQU $6049 numero du lecteur de disquette
DK_TRK EQU $604a n° piste (2 octets)
DK_SEC EQU $604c n° secteur
DK_NUM EQU $604d entrelacement
DK_STA EQU $604e etat courant controleur disquette
DK_BUF EQU $604f adresse buffer secteur (2 octets)
* Zones de travail du controleur SDDRIVE
* On utilise $6051-$6058 (zones de stockage de la position des têtes)
* sauf $6055-$6056 utilise par le moniteur TO8 pour stocker l adresse
* de la routine appelee lors d un changement de banque
SD_LB0 EQU $6051 adresse du debut du fichier .sd dans la carte SD
SD_TYP EQU $6057 type de carte SD=0 SDHC=1
SD_SEL EQU $6058 flag $55 si une disquette est selectionnee
* indicateurs du controleur de disquette
DKFLG EQU $6080 indicateur presence controleur disque
* Zones de travail en pile systeme pour le driver de la carte SD
SD_CMD EQU $608E definition de la commande CMD17 ou CMD24
SD_LBA EQU $608F adresse du secteur courant dans la carte SD
SAVLB0 EQU $6096 sauvegarde de SD_LB0
SAVTYP EQU $609A sauvegarde de SD_TYP
SAVSEL EQU $609B sauvegarde de SD_SEL
* Zones de travail du controleur de disquette
DKWE5 EQU $60e5 code erreur
DKWE7 EQU $60e7 pointeur sur nom de fichier
DKWE9 EQU $60e9 pointeur sur buffer
DKWEB EQU $60eb type de fichier
DKWEC EQU $60ec flag de fichier
DKWED EQU $60ed bloc libre dans la FAT
DKWF0 EQU $60f0 code operation logique
DKWF5 EQU $60f5 numero de secteur
DKWF6 EQU $60f6 numero de bloc
DKWF7 EQU $60f7 nbre d'octets du dernier secteur du fichier
DKWF9 EQU $60f9 numero de bloc alloue
DKWFA EQU $60fa numero du premier secteur du bloc
DKWFB EQU $60fb numero de piste du bloc courant
BUFFER EQU $6200 buffer de lecture/ecriture secteur
* Buffer de lecture des secteurs de la carte SD
BUF512 EQU $9C00 adresse buffer de lecture secteur 512 octets
BNSEC EQU $9C0D nombre de secteurs par cluster (sur 1 octet)
BRES2 EQU $9C0E nombre de secteurs reserves pds faible
BRES1 EQU $9C0F nombre de secteurs reserves pds fort
BFATS2 EQU $9C16 taille FAT16 pds faible
BFATS1 EQU $9C17 taille FAT16 pds fort
BFATS4 EQU $9C24 taille FAT32 pds faible
BFATS3 EQU $9C25 taille FAT32 pds fort
BNFAT EQU $9C10 nombre de FATs
BNDIR2 EQU $9C11 nbre entrees directory pds faible
BNDIR1 EQU $9C12 nbre entrees directory pds fort
BLBA2 EQU $9DC6 LBA partition pds faible
BLBA1 EQU $9DC7 LBA partition pds fort
BBIND EQU $9DBE boot indicator
BSIGN EQU $9DFE adresse de la signature dans le buffer
BUFEND EQU $9E00 adresse de fin du buffer (+1)
* Information sur le partitionnement de la carte SD
CSIZ2 EQU $9E00 nombre de secteurs par cluster (sur 2 octets)
CSIZE EQU $9E01 nombre de secteurs par cluster (sur 1 octet)
SECTR EQU $9E02 nombre de secteurs reserves
SECTP EQU $9E04 numero secteur debut partition
SECTD EQU $9E06 numero secteur debut directory
SECTF EQU $9E08 numero secteur du data cluster 0
*******************************************************
* DESCRIPTION DES FONCTIONS SPECIALES ARDDRIVE
*
* EXCMD Lance une commande pour la carte SD
* - Registre DP = $A7(MO) ou $E7(TO)
* - Registre U = adresse des parametres de la commande
* (code commande + 4 octets + checksum + code retour)
* - Retour registre A (0 = OK, sinon erreur)
* - Les registres ne sont pas preserves (sauf DP)
*
* RS512 Lit un secteur de 512 octets
* - CMDXX+1 = LBA secteur, en $2094(MO) ou $6094(TO)
* - En entrée Y contient l'adresse du buffer
* - Les registres ne sont pas preserves
* - Le registre DP est retabli en $20(MO) ou $60(TO)
*
*******************************************************
*------------------------------------------------------
* ROM DU CONTROLEUR
*------------------------------------------------------
ORG $E000
FCB $53 S controleur carte SD
FCB $54 T fat de 160 octets
FCB $44 D double densite
FCB $40 @ checksum $53+$54+$44+$55=$140
OPTABL
LBRA DKCONT $x004 fonctions standard
LBRA DKBOOT $x007 lancement du boot
LBRA DKFMT $x00A formatage
LBRA LECFA $x00D chargement de la fat
LBRA RECFI $x010 ouverture d'un fichier
LBRA RECUP $x013 effacement d'un fichier
LBRA ECRSE $x016 ecriture d'un secteur
LBRA ALLOD $x019 creation d'un fichier
LBRA ALLOB $x01C allocation d'un bloc
LBRA MAJCL $x01F mise a jour cluster
LBRA FINTR $x022 cloture d'ecriture
LBRA DKSEL $x025 selection d'une disquette
LBRA EXCMD $x028 execution commande pour carte SD
LBRA RS512 $x02B lecture secteur de 512 octets
*------------------------------------------------------
* DKBOOT = Lancement du boot
* Si la carte SD n'est pas initialisee :
* - selection d'une disquette
* - si secteur de boot valide lancement du boot
* - sinon branchement au contenu de $001e
* Si la carte SD est initialisee :
* - si secteur de boot valide lancement du boot
* - sinon retour au programme appelant
*------------------------------------------------------
DKBOOT
LBSR SDINI initialiser la carte SD
BCS DKB9 erreur d'initialisation
CLR <DK_DRV 0 dans le numero de lecteur
CLR <DK_TRK toujours zero
CLR <DK_TRK+1 selection piste 0
LDA #$01 valeur pour secteur 1
STA <DK_SEC selection secteur 1
LEAU BUFFER,PCR adresse du buffer secteur
STU <DK_BUF stockage adresse buffer
LBSR RSECT lecture secteur logique
BCS DKB9 erreur de lecture
LEAU BUFFER,PCR adresse debut de buffer
LEAY $7F,U adresse fin de buffer
PSHS Y empilage adresse fin de buffer
LDA #$55 calcul checksum boot
DKB4
DEC ,U octet - 1
COM ,U complement
ADDA ,U+ ajout checksum
CMPU ,S test fin de buffer
BNE DKB4 octet suivant
PULS Y pour retablir le pointeur de pile
CMPA ,U test checksum boot
BNE DKB9 checksum fausse
JMP BUFFER,PCR execute le boot
DKB9
CLR <DKFLG indicateur de presence controleur
JMP [$001e] lancement application a froid
*------------------------------------------------------
* Execution fonction standard
*------------------------------------------------------
STDOP
LDA <DK_OPC Code operation
BITA #$01 Bit reset
BNE STDOP9 Ne rien faire
LEAY RSECT,PCR Lecture secteur logique
BITA #$02 Bit lecture secteur
BNE STDOP2 Execute lecture secteur
LEAY WSECT,PCR Ecriture secteur logique
BITA #$08 Bit ecriture secteur
BNE STDOP2 Execute ecriture secteur
BITA #$20 Bit recherche piste 0
BNE STDOP9 Ne rien faire
BITA #$40 Bit recherche piste x
BNE STDOP9 Ne rien faire
BITA #$04 Bit passage simple densite
BNE STDOP9 Ne rien faire
BITA #$10 Bit passage double densite
BNE STDOP9 Ne rien faire
LBRA ERR10 Fonction inconnue
STDOP2
JMP ,Y Execution de la fonction
STDOP9
CLRA Clear carry
RTS Retour
*------------------------------------------------------
* DKCONT = Fonctions standard
* Le code erreur en <$4E est initialise a zero
* Il doit être obligatoirement different de zero quand
* le bit carry est positionne au retour de la fonction
* Notez la methode astucieuse pour garder le contenu
* du registre CC en remplacant l'ancien bit carry par
* le carry de retour de la fonction executee.
*------------------------------------------------------
DKCONT
PSHS U,Y,X,DP,B,A,CC empilage des registres
LBSR DPINIT initialisation DP $20 ou $60
CLR <$4E raz du code erreur
BSR STDOP execution de l'operation
PULS A depile ancien CC dans A
EXG A,CC restaure le CC empile
LSRA remplace le bit carry de CC
PULS A,B,DP,X,Y,U,PC retour
*------------------------------------------------------
* INITIALISATION DP POUR ACCES A LA CARTE SD
*------------------------------------------------------
SDCONF
ORCC #$50 desactive les interruptions
TFR PC,D adresse courante
ANDA #$F0 octet $A0 ou $E0
ORA #$07 ajout de 7
TFR A,DP DP=$A7/$E7 pour acces carte SD
RTS
*------------------------------------------------------
* INITIALISATION DP $20 (MO) OU $60 (TO)
*------------------------------------------------------
DPINIT
TFR PC,D D=adresse courante
ANDA #$70 valeur DP fonction de PC
TFR A,DP DP = $20 ou $60
CLRA clear carry
RTS
*------------------------------------------------------
* INITIALISATION DE LA CARTE SD
* CMD0 = SOFTWARE RESET
* Precedee de l'envoi de tops d'horloge (74 mini)
* Sortie en erreur apres 8 essais
*------------------------------------------------------
SDINI
BSR SDCONF initialise DP pour acces carte SD
LDY #$0008 compteur pour 8 boucles
SDINI1
LDA #$0A pour 10 fois 8 tops
LBSR CLOCK envoi de A*8 tops horloge
LEAU CMD0,PCR commande CMD0
LBSR EXCMD0 execution commande CMD0
BCC SDINI2 code retour OK
LEAY -1,Y decrementation compteur
BNE SDINI1 nouvel essai
BRA SDINI9 erreur apres 8 essais
*------------------------------------------------------
* CMD8 = SEND INTERFACE CONDITION
* Non reconnue par les cartes SD de version < 2.00
* c'est pourquoi le code retour n'est pas teste.
* Lire les 4 derniers octets de la reponse R7
*------------------------------------------------------
SDINI2
CLR SD_TYP,PCR carte SD par defaut
LBSR EXCMD execution commande
LDA #$04 pour 4 fois 8 tops
LBSR CLOCK envoi 4 fois 8 tops horloge
*------------------------------------------------------
* CMD55 + ACMD41 = INITIALISATION
* Retry en cas de code retour different de zero
* Abandon apres 255 tentatives.
*------------------------------------------------------
SDINI3
LDY #$0100 compteur pour 255 essais
SDINI4
LEAY -1,Y decrementation compteur
BEQ SDINI9 erreur apres 255 essais
LEAU CMD55,PCR adresse commande CMD55
LBSR EXCMD execution commande CMD55
LBSR EXCMD execution commande ACMD41
BCS SDINI4 carte non prete, nouvel essai
*------------------------------------------------------
* CMD58 = LECTURE OCR
* Permet de determiner le type de carte SD ou SDHC
*------------------------------------------------------
SDINI5
LBSR EXCMD execution commande
BCS SDINI9 erreur commande
LDA <$BF lecture octet
ASLA isole le type de carte
BPL SDINI6 carte SD : SD_TYP=0
INC SD_TYP,PCR carte SDHC : SD_TYP=1
SDINI6
LDA #$03 pour 3 octets
LBSR CLOCK lecture OCR (octets 2, 3, 4)
BRA DPINIT restauration registre DP
*------------------------------------------------------
* Initialisation carte SD terminee en erreur
*------------------------------------------------------
SDINI9
BSR DPINIT restauration registre DP
COMA set carry
RTS retour en erreur
*------------------------------------------------------
* Selection du fichier .sd au premier appel de RSECT
*
* Pour les MO, l'adresse de lancement de l'application
* est stockée dans la memoire video. Elle doit être
* sauvegardee avant l'appel de DKSEL, puis restauree.
* Pour les TO, il ne faut pas la restaurer car
* l'ecriture en ROM changerait la page selectionnee.
*------------------------------------------------------
SDSEL
LDX >$001E adresse lancement application
CLR <SD_SEL RAZ indicateur selection disquette
LBSR DKSEL fonction de selection disquette
BCS SDSEL9 retour carry set en erreur
TFR DP,A DP = $20(MO) ou $60(TO)
CMPA #$20 test ordinateur
BNE SDSEL1 ordinateur TO
STX >$001E restaure adresse de lancement
SDSEL1
LDA <SD_SEL indicateur selection disquette
CMPA #$55 test indicateur
BEQ SDSEL9 la disquette est selectionnee
COMA sinon carry set en erreur
SDSEL9
RTS retour
*------------------------------------------------------
* DKSEL = selection d'un fichier .sd
* L'appel de DKSEL en BASIC necessite
* CLEAR,&H4FFF (MO) ou CLEAR,&H8FFF (TO)
*------------------------------------------------------
DKSEL
PSHS U,Y,X,DP,B,A empilage des registres
BSR SDINI initialisation de la carte
LBCS DKSEL8 retour en cas d'erreur
*------------------------------------------------------
* Lecture du Master Boot Record (1er secteur physique)
* $1FE-$1FF: $55AA (signature)
* Premier descripteur (pour la premiere partition)
* $1BE: boot indicator ($00=non, $80=oui)
* Si boot indicator different, ce n'est pas un MBR
* $1C6-$1C7: LBA (poids faible en tete)
*------------------------------------------------------
RMBR
CLRA raz registre D (octet poids fort)
CLRB raz registre D (octet poids faible)
STD <SD_LBA LBA (2 premiers octets)
STD <SD_LBA+2 LBA (2 derniers octets)
STD >SECTP raz secteur debut partition
LDY #BUF512 adresse du buffer
LBSR RS512 lecture du secteur de 512 octets
LDD #$55AA Signature secteur
CMPD >BSIGN Test signature
LBNE DKSEL8 Signature incorrecte
LSL >BBIND Boot indicator
BNE ABOOT1 Pas de MBR, donc boot record
LDA >BLBA1 LBA partition pds fort
LDB >BLBA2 LBA partition pds faible
STD >SECTP stockage secteur debut partition
*------------------------------------------------------
* Lecture du Boot Record
* Premier secteur au debut de la partition
* Registre D = numero secteur de debut de partition
*------------------------------------------------------
RBOOT
STD <SD_LBA+2 stockage pour CMD17 si carte SDHC
TST <SD_TYP test du type de carte
BNE RBOOT1 carte SDHC, sinon calcul pour SD
ASLB multiplie par 2 (poids faible)
ROLA multiplie par 2 (poids fort)
STD <SD_LBA+1 adresse = numero secteur * $200
CLRB raz registre A
STB <SD_LBA+3 raz dernier octet adresse
RBOOT1
LDY #BUF512 adresse du buffer
LBSR RS512 lecture du secteur de 512 octets
*------------------------------------------------------
* Analyse du Boot Sector
* $1FE-$1FF: $55AA (signature)
* $00B-$00C: nombre d'octets par secteur (512)
* $00D: nombre de secteurs par cluster
* $00E-$00F: nombre de secteurs reserves
* $010: nombre de FATs
* $011-$012: nombre entrees directory (FAT16 seulement)
* $016-$017: nombre secteurs FAT (FAT16 seulement)
* $024-$027: nombre secteurs FAT (FAT32 seulement)
* $02C-$02D: numero cluster directory (FAT32)
* Attention: le debut des donnees commence au cluster 2
* - En FAT16: apres la directory
* - En FAT32: apres les FATs
* Pour faciliter les calculs, on retranche 2 fois le
* nombre de secteurs par cluster au debut des donnees.
*
* Calcul du secteur physique du repertoire principal
* = numero du secteur de debut de partition
* + nombre de secteurs reserves
* + nombre de secteurs FAT * nombre de FAT
*
* Calcul du secteur physique du cluster zero
* = numero du secteur du debut du repertoire principal
* + nombre d'entrees repertoire / 16 (0 en FAT32)
* - nombre de secteurs par cluster * 2
*
*------------------------------------------------------
ABOOT
LDD #$55AA Signature secteur
CMPD >BSIGN Test signature
LBNE DKSEL8 Signature incorrecte
ABOOT1
CLRA
LDB >BNSEC Nombre de secteurs par cluster
STD >CSIZ2 Stockage nbre secteurs par cluster
LDA >BRES1 Blocs reserves pds fort ex: $00
LDB >BRES2 Blocs reserves pds faible ex: $04
STD >SECTR stockage nbre secteurs reserves
* taille FAT (en FAT16) dans D
LDA >BFATS1 Fat16 size pds fort ex: $00
LDB >BFATS2 Fat16 size pds faible ex: $F2
STD >BFATS2 stockage taille FAT16
BNE ABOOT2 FAT16 si different de zero
* taille FAT (en FAT32) dans D
* 2 octets poids fort ignores (simplification abusive ?)
LDA >BFATS3 Fat32 size pds fort ex: $03
LDB >BFATS4 Fat32 size pds faible ex: $AB
* taille totale fonction du nombre de FATs
* le nombre de secteurs des FATs est stocke dans le registre D
ABOOT2
DEC >BNFAT Nombre de FAT ex: $02
BEQ ABOOT3 Une seule FAT
ASLB FAT size multiplie par 2 ex: $E4
ROLA FAT size multiplie par 2 ex: $01
ABOOT3
ADDD >SECTR ajout nombre de secteurs reserves
ADDD >SECTP ajout secteur de debut de partition
STD >SECTD stockage secteur debut directory
LDA >BNDIR1 nbre entrees directory (poids fort)
LDB >BNDIR2 nbre entrees directory (poids faible)
LSRA division par 16
RORB pour obtenir
LSRA le nombre de secteurs
RORB de la directory
LSRA En FAT32 le nombre d'entrees
RORB de la directory est nul
LSRA Le debut des donnees (cluster 2)
RORB commence apres les FATs
ADDD >SECTD ajout secteur debut directory
SUBD >CSIZ2 retrancher le nbre secteurs/cluster
SUBD >CSIZ2 retrancher le nbre secteurs/cluster
STD >SECTF stockage numero secteur du cluster 0
LDD >SECTD secteur de debut de directory
*------------------------------------------------------
* LECTURE DE LA DIRECTORY
* D contient le numero du secteur a lire
*------------------------------------------------------
RDSECT
STD <SD_LBA+2 stockage pour la commande 17
TST <SD_TYP type de carte 0=SD 1=SDHC
BNE RDSEC1 carte SDHC
ASLB LBA multiplie par 2
ROLA LBA multiplie par 2
STD <SD_LBA+1 LBA multiplie par $100
CLRB
STB <SD_LBA+3 octet de poids faible a zero
RDSEC1
LDY #BUF512 adresse du buffer
LBSR RS512 lecture du secteur
LDX #BUF512 adresse du buffer
*------------------------------------------------------
* RECHERCHE FICHIER ARDDRIVE.SEL DANS LA DIRECTORY
* Le registre X pointe sur l'entree en cours
*------------------------------------------------------
RDIR1
CLRB zero
CMPB ,X Test premier octet
LBEQ DKSEL8 Fin de repertoire
LEAY FNAME,PCR pointeur nom de fichier
CLRA pointeur dans le nom
RDIR2
LDB A,Y caractere du nom de fichier
CMPB A,X test du caractere
BNE RDIR3 difference de nom
INCA numero du caractere suivant
CMPA #$0B test fin du nom de fichier
BEQ FSEL le nom est identique
BRA RDIR2 test caractere suivant
FNAME
FCC "ARDDRIVESEL" nom du programme de selection
RDIR3
LEAX 32,X Adresse entree suivante
CMPX #BUFEND Fin du buffer
BNE RDIR1 Traitement entree suivante
* lecture secteur suivant
LDD >SECTD secteur debut directory
ADDD #$0001 secteur suivant
STD >SECTD nouveau debut directory
BRA RDSECT lecture secteur directory
*------------------------------------------------------
* INITIALISATION DU LBA DU FICHIER ARDDRIVE.SEL
* CSIZE = nombre de secteurs par cluster (1 octet)
* FSECT = numero de secteur du cluster 0 (2 octets)
* 26,X = n° cluster relatif au boot sector (poids faible)
* 27,X = n° cluster relatif au boot sector (poids fort)
* LBA0 = XX YY
* N*CLUSTER = UU VV 00 (UU VV = N*A)
* + 00 ZZ TT (ZZ TT = N*B)
* LBA = (UU+carry2) (VV+XX+ZZ+carry1) (TT+YY)
* /|\ | /|\ |
* |_____| |_____|
* (adaptation du code original de Samuel Devulder)
*------------------------------------------------------
FSEL
LDD >SECTF ; secteur origine
STD <SD_LBA+2 ; stockage secteur origine
LDA 27,X ; Cluster poids fort
LDB >CSIZE ; Nombre de secteurs par cluster
MUL ; D = msb(CLUSTER)*N = UU VV
ADDB <SD_LBA+2 ; octet de poids fort du secteur origine
ADCA #0 ; D = UU (VV+XX). Nota: Si SD_LBA+1 contient déjà 0, ADDD SD_LBA+1 suffit.
STD <SD_LBA+1 ; sauvé en SD_LBA+1
LDA 26,X ; Cluster poids faible
LDB >CSIZE ; Nombre de secteurs par cluster
MUL ; D = lsb(CLUSTER)*N = ZZ TT
ADDD <SD_LBA+2 ; D = (VV+XX+ZZ+carry1) (TT+YY)
STD <SD_LBA+2 ; (VV+XX+ZZ+carry1) (TT+YY) placé en LBA+2
LDB <SD_LBA+1 ; B=UU
ADCB #0 ; B=UU+carry2
CLRA ; A=0
STD <SD_LBA ; SD_LBA = 00 (UU+carry2) (VV+XX+ZZ+carry1) (TT+YY)
TST <SD_TYP
BNE FLOAD ; ben oui tout est déjà fait pour les cartes SDHC
* recopie + decalage pour carte SD
STB ,-S ; sauvegarde UU+carry2
LDD <SD_LBA+2 ; D=(VV+XX+ZZ+carry1) (TT+YY)
LSLB
ROLA ; D*2
STD <SD_LBA+1 ; sauvé en SD_LBA+1
LDB ,S+ ; UU+carry2
ROLB ; (UU+carry2)*2 + "carry de D*2"
STB <SD_LBA ; sauvé en SD_LBA
CLR <SD_LBA+3 ; 0 au bon endroit
*------------------------------------------------------
* CHARGEMENT ET EXECUTION DU FICHIER ARDDRIVE.SEL
*------------------------------------------------------
FLOAD
LDY #$9000 adresse du buffer
FLOAD1
LBSR RS512 lecture du secteur de 512 octets
BSR NEXTS calcul LBA du secteur suivant
CMPY #$9800 test de fin
BNE FLOAD1 secteur suivant
* execution
JSR $9000 lancement programme ARDDRIVE.SEL
LDA #$55 indicateur "disquette selectionnee"
STA <SD_SEL stockage de l'indicateur
BRA DKSEL9 retour OK
DKSEL8
COMA retour en erreur carry=1
DKSEL9
PULS A,B,DP,X,Y,U,PC retour
*------------------------------------------------------
* CALCUL LBA DU SECTEUR SUIVANT
*------------------------------------------------------
NEXTS
TST <SD_TYP type de carte 0=SD 1=SDHC
BNE NEXTS1 carte SDHC
LDD <SD_LBA+1 n° de secteur multiplie par 2
ADDD #$0002 secteur suivant
STD <SD_LBA+1 n° de secteur multiplie par 2
BRA NEXTS9 retour
NEXTS1
LDD <SD_LBA+2 n° de secteur
ADDD #$0001 secteur suivant
STD <SD_LBA+2 n° de secteur
NEXTS9
RTS
*------------------------------------------------------
* Calcul du LBA carte SD : SD_LBA =
* SD_LBA0+(512-511*SD_TYP)*(1280*DK_DRV+16*DK_TRK+DK_SEC-1)
* DK_DRV n° lecteur de disquette
* DK_TRK n° piste (2 octets)
* DK_SEC n° secteur
* SD_TYP type SD/SDHC
* (adaptation du code original de Samuel Devulder)
* carry set si erreur, code erreur dans A
*------------------------------------------------------
SETLBA
PSHS U,X,B,A empilage des registres utilise
LEAU SD_LBA,PCR U=adresse du LBA
LDB <DK_TRK+1 numero de piste
BMI SETLB8 erreur secteur
CMPB #$50 test piste 80
BHS SETLB8 erreur secteur
LDA #16 nombre de secteurs par piste
MUL multiplie par numero de piste
TFR D,X X=DK_TRK*16
LDB <DK_SEC numero du secteur
BEQ SETLB8 erreur secteur=0
CMPB #$10 test secteur 16
BHI SETLB8 erreur secteur>16
DECB ramene intervalle [0-15]
ABX X=DK_TRK*16+DK_SEC-1
CLRA A=0
CLRB B=0
STD ,U LBA(poids fort) initialise a zero
LDA <DK_DRV A=numero d'unite
CMPA #$04 test unite 4
BHS SETLB7 erreur unite>=4
LSLA multiplie par 2
LSLA multiplie par 2
ADDA <DK_DRV ajoute l'unite (5*256=1280)
LEAX D,X X=1280*DK_DRV+16*DK_TRK+DK_SEC-1
TFR X,D valeur dans D
* multiplication par 512-511*SD_TYP
LEAX 4,U type de carte
TST <SD_TYP test type de carte
BNE SETLB2 carte SDHC
LSLB pour carte SD il faut multiplier
ROLA le numero de secteur par deux
CLR ,-X raz octet de poids faible du LBA
SETLB2
STD -2,X SD_LBA = 0 XX XX 0 ou 0 0 XX XX
* addition SD_LBA = SD_LBA + SD_LB0 sur 32bits
LDD <SD_LB0+2
ADDD 2,U
STD 2,U
LDD <SD_LB0
ADCB 1,U
ADCA #0 en vrai ",u" mais c'est équivalent car on a toujours 0 à cette adresse
STD ,U
CLRA clear carry
PULS A,B,X,U,PC retour sans erreur
SETLB7
PULS A,B,X,U depilage registres
LDA #$10 erreur unite
BRA SETLB9 retour en erreur
SETLB8
PULS A,B,X,U depilage registres
LDA #$04 erreur de secteur
SETLB9
COMB set carry
RTS retour en erreur
*------------------------------------------------------
* Erreur unite ou lecteur non pret
*------------------------------------------------------
ERR10
LDA #$10 code erreur unite
*------------------------------------------------------
* Retour d'un code erreur transmis par le registre A
* $01 = disquette protegee
* $02 = erreur de piste
* $04 = Erreur de secteur
* $08 = Erreur de donnees
* $10 = Erreur unite ou lecteur non pret
* $20 = Erreur de verification
*------------------------------------------------------
ERRSET
LBSR DPINIT retablissement valeur DP
STA <DK_STA stocke le code erreur
COMA set carry
RTS retour
*------------------------------------------------------
* EXECUTION DE LA COMMANDE DE CODE A
*------------------------------------------------------
EXCMDA
STA <SD_CMD initialise code commande
CLR <SD_CMD+6 initialise code retour
LBSR SDCONF configuration pour acces carte SD
LEAU SD_CMD,PCR adresse de la commande dans U
*------------------------------------------------------
* ATTENTE CARTE PRETE AVANT EXECUTION D'UNE COMMANDE
* Appel necessaire pour toutes les commandes sauf CMD0
* Lors de l'envoi de CMD0 la carte n'est pas encore
* prete, il faut appeler directement EXCMD0
* EXCMD doit preserver le registre Y (index buffer)
*------------------------------------------------------
EXCMD
LDX #$1000 compteur pour 4095 boucles
EXCMD1
LEAX -1,X decrementation compteur
BEQ EXCMD4 retour en erreur
LDA <$BF lecture octet dans A
INCA ajout de 1 ($FF --> $00)
BNE EXCMD1 nouvel essai
*------------------------------------------------------
* EXECUTION D'UNE COMMANDE POINTEE PAR U
* Le registre U pointe sur les 6 octets de la commande
* Le registre B n'est pas preserve.
* le code retour est dans le registre A
*------------------------------------------------------
EXCMD0
LDB #$06 nombre d'octets de commande
EXCMD2
LDA ,U+ chargement octet de commande
STA <$BF ecriture octet
DECB decrementation compteur
BNE EXCMD2 il reste des octets a envoyer
LDX #$0100 compteur pour 255 essais
LDB #$7F initialisation de B pour lecture
EXCMD3
LEAX -1,X decrementation compteur
BEQ EXCMD4 pas de reponse
LDA <$BF lecture octet
CMPA ,U+ test code de retour
BEQ EXCMD5 code bon
BRA EXCMD3 nouvelle lecture
EXCMD4
COMB carry set en erreur
EXCMD5
RTS retour
*------------------------------------------------------
* Lecture d'un secteur de 512 octets
* LBA pre-initialise dans CMDXX
* En entree Y contient l'adresse du buffer
* En sortie Y contient l'adresse du buffer + 512
* DK_BUF n'est plus utilise dans cette version
*------------------------------------------------------
RS512
LBSR DPINIT initialisation DP $20 ou $60
LDA #$51 code CMD17
BSR EXCMDA execution CMD17
BCS RS519 erreur commande
LDX #$0100 compteur pour 255 boucles
RS513
LEAX -1,X decrementation compteur
BEQ RS519 sortie si timeout
LDA <$BF lecture octet
CMPA #$FE comparaison avec $FE
BNE RS513 attente debut secteur
* lire 512 octets
RS515
LDX #$0200 compteur pour 512 boucles
RS516
LDA <$BF lecture octet
STA ,Y+ stockage dans le buffer
LEAX -1,X decrementation compteur
BNE RS516 nouvelle lecture
* ignorer 2 octets de CRC
LDA #$02 pour 2 octets
LBSR CLOCK ignorer 2 octets CRC
LBSR DPINIT retablissement valeur DP
CLRA clear Carry
RS519
RTS retour
*------------------------------------------------------
* Lecture d'un secteur disquette dans buffer 256 octets
* Les 256 octets suivants sont ignores
* LBA fonction de: unite, piste, secteur, type carte
* Adresse du buffer dans DK_BUF
* Ecriture du buffer indexee par le registre Y
*------------------------------------------------------
RSECT
LDA #$55 valeur de l'indicateur
* sauvegarder LB0 et TYP si disponible
CMPA <SD_SEL indicateur de selection
BEQ RSECT2 sauvegarder la selection
* restaurer LB0 et TYP si sauvegarde disponible
CMPA <SAVSEL indicateur de sauvegarde
BEQ RSECT1 restaurer la selection
* Selection fichier .sd au premier appel de RSECT
LBSR SDSEL selection fichier .sd
BCS ERR10 erreur de selection
BRA RSECT2 sauvegarde selection
* Restaurer 6 octets depuis la zone de
* sauvegarde en bas de la pile systeme
RSECT1
LDD <SAVLB0 poids fort SAVLB0
STD <SD_LB0 restauration
LDD <SAVLB0+2 poids faible SAVLB0
STD <SD_LB0+2 restauration
LDD <SAVTYP SAVTYP et SAVSEL
STD <SD_TYP restauration
BRA RSECT3
* Sauvegarder 6 octets vers la zone de
* sauvegarde en bas de la pile systeme
RSECT2
LDD <SD_LB0 poids fort SD_LB0
STD <SAVLB0 sauvegarde
LDD <SD_LB0+2 poids faible SD_LB0
STD <SAVLB0+2 sauvegarde
LDD <SD_TYP SD_TYP et SD_SEL
STD <SAVTYP sauvegarde
* Lancer CMD17 et attendre le debut du secteur
RSECT3
LBSR SETLBA calcul SD_LBA
LBCS ERRSET erreur unite/piste/secteur
LDY <DK_BUF adresse du buffer
LDA #$51 code CMD17
LBSR EXCMDA execution CMD17
LBCS ERR10 erreur unite/piste/secteur
LDX #$0100 compteur pour 255 boucles
RSECT4
LEAX -1,X decrementation compteur
LBEQ ERR10 erreur timeout
LDA <$BF lecture octet
CMPA #$FE comparaison avec $FE
BNE RSECT4 attente debut secteur
* Lire 256 octets et ignorer 256
LDX #$0100 compteur pour 256 boucles
RSECT5
LDA <$BF lecture octet
STA ,Y+ ecriture dans le buffer
LEAX -1,X decrementation compteur octets
BNE RSECT5 nouvelle lecture
CLRA pour 256 fois 8 tops
BSR CLOCK envoi de 256 * 8 tops
* Ignorer 2 octets de CRC
LDA #$02 pour 2 octets
BSR CLOCK ignorer 2 octets
LBSR DPINIT retablissement valeur DP
CLRA clear Carry
RTS retour sans erreur
*------------------------------------------------------
* ENVOI DE 8*A TOPS D'HORLOGE
* Le registre B est preserve. Au retour A=0
*------------------------------------------------------
CLOCK
CMPB <$BF
DECA
BNE CLOCK
RTS
*------------------------------------------------------
* Ecriture d'un secteur disquette
* dans secteur SD complete a 512
*------------------------------------------------------
WSECT
LDA <SD_SEL indicateur "disquette selectionnee"
CMPA #$55 test indicateur
LBNE ERR10 pas de disquette selectionnee
LBSR SETLBA calcul SD_LBA
LBCS ERRSET erreur unite/piste/secteur
LDA #$58 code CMD24
LBSR EXCMDA execution CMD24
LBCS ERR10 erreur commande
LDA #$FE indicateur debut bloc
STA <$BF ecriture octet
* Ecrire 256 octets du buffer + 256 octets $FF
LDY <DK_BUF adresse du buffer
LDX #$0100 compteur pour 256 boucles
WSECT2
LDA ,Y+ lecture dans le buffer
STA <$BF ecriture octet
LEAX -1,X decrementation compteur octets
BNE WSECT2 nouvelle ecriture
CLRA pour 256 fois 8 tops
BSR CLOCK ecrire 256 octets $FF
* Ecrire 2 octets de CRC $FF
LDA #$02 pour 2 octets
BSR CLOCK envoi 2 fois 8 tops horloge
LBSR DPINIT retablissement valeur DP
CLRA clear Carry
RTS retour sans erreur
*------------------------------------------------------
* Recherche piste
* Recherche piste 0
*------------------------------------------------------
FINDT
FIND0
CLRA clear CC
RTS retour
*------------------------------------------------------
* DKFMT = formatage de la disquette
*------------------------------------------------------
DKFMT
PSHS U,Y,X,DP,B,A,CC
ORCC #$50 desactive les interruptions
LBSR DPINIT initialisation DP $20 ou $60
CLR <DK_TRK 0 dans piste poids fort
CLR <DK_TRK+1 0 dans piste poids faible
LBSR FMTRK formatage piste 0
LBSR INIT20 initialisation piste 20
PULS CC,A,B,DP,X,Y,U,PC
*------------------------------------------------------
* Formatage d'une piste
*------------------------------------------------------
FMTRK
LDA #$E5 caractere de remplissage
BSR INIBUF remplissage buffer
LDA #$01 numero premier secteur
STA <DK_SEC stockage numero secteur
FMTRK1
BSR WSECT ecriture d'un secteur
LDA <DK_SEC numero de secteur
CMPA #$10 secteur 16
BEQ FMTRK9 fin de piste
INCA incrementation secteur
STA <DK_SEC stockage numero secteur
BRA FMTRK1 secteur suivant
FMTRK9
RTS retour
*------------------------------------------------------
* Remplissage du buffer de secteur
*------------------------------------------------------
INIBUF
LDY <DK_BUF initialisation adresse
CLRB nombre octets secteur
INIB1
STA ,Y+ stockage octet remplissage
DECB decrementation compteur
BNE INIB1 octet suivant
RTS retour
*------------------------------------------------------
* Initialisation piste 20
*------------------------------------------------------
INIT20
LDX #$0014 piste 20
STX <DK_TRK
LDA #$FF valeur de remplissage
BSR INIBUF remplissage buffer
LDA #$08
ORA <DK_OPC
STA <DK_OPC
CLRB initialisation n° secteur
INIT21
INCB secteur suivant
STB <DK_SEC
LBSR DKCONT ecriture du secteur
BLO INIT29
CMPB #$10 secteur 16
BNE INIT21
LDX <DK_BUF
CLR ,X premier octet FAT = 0
LDD #$FEFE blocs reserves
STD $29,X pour piste 20
LDA #$02
STA <DK_SEC
LBSR DKCONT ecriture du secteur
BLO INIT29 retour en erreur
CLRA pas d'erreur
INIT29
RTS
*------------------------------------------------------
* SCRATCH DOS
*------------------------------------------------------
SCRDOS
FCC "SCRATCH"
FCC " DOS"
*------------------------------------------------------
* FINTR = cloture d'ecriture
*------------------------------------------------------
FINTR
LDB <DKWF0 code operation logique
CMPB #$02
BEQ FINTR3
DEC <DKWF0 code operation logique
BSR RECFI ouverture fichier
BLO FINTR9
TSTB
BEQ FINTR1
LBSR RECUP
BLO FINTR9
FINTR1
INC <DKWF0 code operation logique
BSR RECFI
BLO FINTR9
LDB #$0a
LDX <DKWE7
FINTR2
LDA B,X
STA B,Y
DECB
BGE FINTR2
BSR ECRSE ecriture secteur
BLO FINTR9
****************** sauvegarde de la FAT
FINTR3
LDA #$02
STA <DK_SEC secteur 2
LDB #$14
CLRA
STD <DK_TRK piste 20
LDD <DKWED adresse de la FAT
STD <DK_BUF adresse du buffer secteur
BSR ECRSE ecriture secteur
BLO FINTR9 erreur ecriture
CLR <$f0 indicateur cloture fichier
FINTR9
RTS
*------------------------------------------------------
* LECFA = Lecture de la FAT
*------------------------------------------------------
LECFA
LDX <DKWED adresse de la FAT
STX <DK_BUF adresse du buffer secteur
LDA #$02 numero secteur a lire
BRA LSEC20 lecture secteur piste 20
*------------------------------------------------------
* Sortie en erreur
*------------------------------------------------------
RETERR
STA <DKWE5
COMA
COMA
RTS
*------------------------------------------------------
* Chargement 1er secteur catalogue
*------------------------------------------------------
LDIR0
LDA #$03
LDX <DKWE9 pointeur sur buffer
STX <DK_BUF
*------------------------------------------------------
* Chargement secteur piste 20
*------------------------------------------------------
LSEC20
STA <DK_SEC
LDB #$14
CLRA
STD <DK_TRK
LDA #$02
BRA SECTIO
*------------------------------------------------------
* ECRSE = Ecriture d'un secteur
*------------------------------------------------------
ECRSE
LDA #$08
*------------------------------------------------------
* Operation sur secteur
*------------------------------------------------------
SECTIO
STA <DK_OPC
LDY <DKWE9 pointeur sur buffer
LBSR OPTABL
LDA #$03
RTS
*------------------------------------------------------
* RECFI = Ouverture d'un fichier
*------------------------------------------------------
RECFI
BSR LDIR0 charge 1er secteur catalogue
RECFI1
BLO RETERR sort si erreur
LDX #$0008 compteur de noms dans X
LDY <DKWE9 pointeur sur buffer
RECFI2
LDU <DKWE7
LDB <DKWF0 code operation logique
CMPB #$03
BNE RECFI3
LEAU SCRDOS,PCR adresse du nom de fichier
RECFI3
CLRB
RECFI4
CMPB #$0b
BHS RECFI8
LDA B,Y
CMPA #$ff
BEQ RECFI7
INCB
CMPA ,U+
BEQ RECFI4
LEAY $20,Y
LEAX -$01,X
BNE RECFI2
INC <DK_SEC
LDA <DK_SEC
CMPA #$10
BHI RECFI7
LBSR OPTABL
LDA #$03 erreur I/O
BRA RECFI1
RECFI7
CLRB
BRA RECFI9
RECFI8
LDB $0b,Y
CMPB <DKWEB
BNE RECFI7
LDB $0c,Y
CMPB <DKWEC
BNE RECFI7
LDB <DK_SEC
LDA $0d,Y
STA <DKWF6
CLR <DKWF5
LDX $0e,Y
STX <DKWF7
STY <DKWFA
RECFI9
STB <DKWF9 numero de bloc alloue
CLRA
RTS
*------------------------------------------------------
* ALLOD = allocation d'un fichier
*------------------------------------------------------
ALLOD
LDY <DKWED adresse de la FAT
BSR ALLOB4 test place libre
ALLOD1
BLO RECFI1 erreur plus de place
STB <DKWF6 numero de bloc
LBSR LDIR0 charge debut directory
ALLOD2
BLO ALLOD1 sortie en erreur
LDY <DKWE9 pointeur sur buffer
LDX #$0008 compteur de noms dans X
ALLOD3
LDB ,Y premier octet du nom
BEQ ALLOD6 0=fichier efface
LDA #$05
CMPB #$ff
BEQ ALLOD6
LEAY $20,Y
LEAX -$01,X
BNE ALLOD3
INC <DK_SEC
LDA <DK_SEC
CMPA #$10
BHI ALLOD4
LBSR OPTABL charge le secteur suivant
LDA #$03
BRA ALLOD2
ALLOD4
LDA #$05 code "disque plein"
ALLOD5
BRA ALLOD1 sort avec erreur
ALLOD6
LDX <DKWE7
LDB <DKWF0 code operation logique
CMPB #$03
BNE ALLOD7
LEAX SCRDOS,PCR adresse nom de fichier
ALLOD7
LDB #$0a
ALLOD8
LDA B,X recopie le nom de fichier
STA B,Y dans le catalogue
DECB
BGE ALLOD8
LDA <DKWEB type de fichier
STA $0b,Y
LDA <DKWEC recopie le numero de bloc
LDB <DKWF6 dans le catalogue
STD $0c,Y
LBRA ECRSE ecriture du repertoire
*------------------------------------------------------
* ALLOB = allocation d'un bloc
*------------------------------------------------------
ALLOB
LDB <DKWF6 numero de bloc
CMPB #$50
BHI ALLOB3
ALLOB1
TSTB
ALLOB2
BEQ ALLOB4
LDA B,Y
CMPA #$ff
BEQ ALLOB8
DECB
CMPB #$50
BLS ALLOB1
ALLOB3
ADDB #$02
CMPB #$A1
BRA ALLOB2
ALLOB4
LDB #$50
ALLOB5
LDA #$05
CMPB #$A0
LBHI RETERR
LDA B,Y
CMPA #$ff
BEQ ALLOB8
PSHS B
SUBB #$50
NEGB
ADDB #$50
LDA B,Y
CMPA #$ff
BEQ ALLOB6
PULS B
INCB
BRA ALLOB5
ALLOB6
LEAS $01,S
ALLOB8
CLR B,Y
DECB
STB <DKWF9 numero de bloc alloue
ALLOB9
CLRA
RTS
*------------------------------------------------------
* RECUP = liberation d'un bloc
*------------------------------------------------------
RECUP
LDA $0d,Y
STA <DKWF6 numero de bloc
CLR ,Y
LBSR ECRSE
BLO ALLOD5
LDY <DKWED
LDB <DKWF6 numero de bloc
RECUP1
INCB
LDA B,Y
CLR B,Y
DEC B,Y
TFR A,B
CMPA #$c0
BLO RECUP1
BRA ALLOB9
*------------------------------------------------------
* MAJCL = Mise a jour cluster
*------------------------------------------------------
MAJCL
LDB <DKWF6 numero bloc
CLRA
LSRB divise par 2
STD <DKWFB numero piste
INCA
STA <DKWF5
BHS MAJCL9
LDA #$09
MAJCL9
STA <DKWFA
RTS
*------------------------------------------------------
* COMMANDES CARTE SD
*------------------------------------------------------
CMD0
FCB $40 go iddle state
FDB $0000
FDB $0000
FCB $95 checksum obligatoire
FCB $01 code retour attendu
*------------------------------------------------------
CMD8
FCB $48 send interface condition
FDB $0000
FDB $01AA
FCB $87 checksum obligatoire
FCB $00 code retour attendu
*------------------------------------------------------
CMD55
FCB $77 application command
FDB $0000
FDB $0000
FCB $FF checksum non testee
FCB $00 code retour attendu
*------------------------------------------------------
AC41
FCB $69 activate card initialization
FDB $4000
FDB $0000
FCB $FF checksum non testee
FCB $00 code retour attendu
*------------------------------------------------------
CMD58
FCB $7A read OCR
FDB $0000
FDB $0000
FCB $FF checksum non testee
FCB $00 code retour attendu
*------------------------------------------------------
*------------------------------------------------------
* Signature de l'EPROM
*------------------------------------------------------
ORG $E6FF
FCB $A0 signature ARDDRIVE
*------------------------------------------------------
* Commentaires
*------------------------------------------------------
FCC 'Controleur de ca'
FCC 'rte SD pour les '
FCC 'ordinateurs Thom'
FCC 'son TO et MO. '
FCC 'Simule quatre un'
FCC 'ites de disquett'
FCC 'es 3"1/2 double '
FCC 'densite avec un '
FCC 'Arduino servant '
FCC "d'interface avec"
FCC ' une carte SD. '
FCC ' '
FCC '================'
FCC 'Daniel Coulom '
FCC 'dcmoto.free.fr '
FCC 'Vers. 2019.04.11'
END
Daniel
L'obstacle augmente mon ardeur.
L'obstacle augmente mon ardeur.
Re: [THOMSON] ARDDRIVE
Ensuite le programme de sélection du fichier .sd (à copier sur la carte) :
Code : Tout sélectionner
/**************************************************\
* A R D D R I V E _ S E L *
* (c) 2019 - Daniel Coulom *
* http://dcmoto.free.fr/ *
* http://forum.system-cfg.com/ *
*--------------------------------------------------*
* Ce code est distribue gratuitement dans l'espoir *
* qu'il sera utile, mais sans aucune garantie et *
* sans engager la responsabilité de l'auteur. *
* Vous pouvez l' utiliser, le modifier et le *
* diffuser librement, en conservant cette licence *
* et les références de l'auteur dans toutes les *
* copies. L'exploitation commerciale est interdite.*
\**************************************************/
* Ce programme permet de selectionner un fichier .sd
* dans une liste deroulante et de monter l'image.
* Cette version est compatible avec les cartes SD
* et SDHC sur MO et sur TO
* Restrictions :
* - 364 fichiers maxi dans le repertoire principal
* - En FAT32 limitation supplementaire en fonction
* de la taille de l'unite d'allocation et de la
* taille des noms longs :
* 4096 = environ 32 fichiers de 39 caracteres
* 8192 = environ 64 fichiers de 39 caracteres
* 16Ko = environ 128 fichiers de 39 caracteres
* 32Ko = environ 256 fichiers de 39 caracteres
*
* Occupation memoire :
* - programme en $9000-$9CFF
* - buffer lecture secteur en $9D00-$9EFF
* - pile systeme deplacee en $9F00-$9FFF
* - table des noms en $5000-$8FFF (MO)
* ou $A000-$DFFF (TO)
* Pour appeler le programme ARDDRIVE_SEL en BASIC
* faire CLEAR,&H4FFF (MO) ou CLEAR,&H8FFF (TO)
*
* Nota :
* La pile systeme est deplacee en $9CFF pour eviter
* que la routine d'affichage d'un caractere (WCHAR)
* ecrase les zones de travail du controleur ARDDRIVE
* (SD_LB0, SD_TYP, SD_CMD et SD_LBA)
/**************************************************\
* Version 2019.04.10 *
\**************************************************/
* Historique
* 2019.04.10 Nouveau logo ARDDRIVE
* 2019.04.09 Version initiale issue de SDDRIVE.SEL
*------------------------------------------------------
* DEFINITION DES ZONES DE TRAVAIL EN RAM
*------------------------------------------------------
SD_LB0 EQU $51 adresse du LBA du fichier .sd
SD_TYP EQU $57 type de carte SD=0 SDHC=1
SD_CMD EQU $8E adresse du code commande
SD_LBA EQU $8F adresse du LBA du secteur a lire
*------------------------------------------------------
* INITIALISATIONS EN FONCTION DE L'ORDINATEUR
*------------------------------------------------------
ORG $9000
INIT
STS SAVES sauvegarde du registre S
LDS #$9CFF nouvelle valeur du registre S
ORCC #$50 desactive les interruptions
LDA #$60 valeur initialisation DP pour TO
LDB >$FFF2 poids fort du vecteur SWI3
BPL INIT1 positif --> TO
*------------------------------------------------------
* Initialisations speciales pour MO
*------------------------------------------------------
LDD #$A02B adresse fonction RS512
STD RS512 stockage adresse
LDD #$5000 adresse de la table des noms
STD TDEB adresse debut de table
STD TFIN adresse fin de table
STD TTOP adresse nom en haut de l'ecran
STD TSEL adresse nom selectionne
LDD #$9000 adresse table des noms + $4000
STD TMAX adresse haute de la table des noms
LDD #$3F82 affichage caractere MO = SWI #$82
STD WCHAR modification routine affichage
LDB #$8A lecture clavier MO = SWI #$8A
STD RCHAR modification routine lecture
LDB #$7B code inversion video pour MO
STB INVER1+1 modification code inversion video
LDA #$20 valeur initialisation DP pour MO
*------------------------------------------------------
* Initialisation de l'ecran
*------------------------------------------------------
INIT1
TFR A,DP DP = $20(MO) ou $60(TO)
SUBA #$20 adresse ecran poids fort
CLRB adresse ecran poids faible
TFR D,X debut ecran
ADDD #$0500 taille du logo 32x40=1280
PSHS B,A empilage adresse fin logo
LDY #ECRAN adresse chaine initialisation ecran
LBSR WSTR affichage d'une chaine
*------------------------------------------------------
* Affichage du logo ARDDRIVE
*------------------------------------------------------
LOGO
LDY #SDLOGO index donnees
LOGO1
LDB #$01 nombre octets identiques
LDA ,Y+ lecture octet donnee
BEQ LOGO9 fin des donnees
CMPA #$20 nombre maxi repetitions
BHI LOGO2 ce n'est pas une repetition
TFR A,B nombre de repetitions
LDA ,Y+ lecture octet donnee
LOGO2
ADDA #$43 ajouter 67
LOGO3
STA ,X afficher l'octet donnee
LEAX $28,X passage ligne suivante
CMPX ,S fin du logo dans l'ecran
BLO LOGO4 fin non encore atteinte
LEAX -$4FF,X debut colonne suivante
LOGO4
DECB decrementation compteur
BNE LOGO3 nouvelle repetition
BRA LOGO1 sequence suivante
LOGO9
PULS A,B depilage D
*------------------------------------------------------
* LECTURE DU PREMIER SECTEUR DE LA CARTE (MBR ou BOOT)
* Table des partitions en $1BE-$1FD
* Premiere partition en $1BE-$1CD
* - $1BE = Boot Indicator ($00=inactif, $80=actif)
* - $1BF-$1C1 = Starting CHS values
* - $1C2 = Partition type descriptor
* 04: FAT16 size less than 32 MB
* 06: FAT16 size greater or equal 32 MB
* 0B: FAT32
* - $1C3-$1C5 = Ending CHS values
* - $1C6-$1C9 = Starting sector
* - $1CA-$1CD = Partition size in sectors
* Signature en $1FE-$1FF = $55AA
*------------------------------------------------------
LBSR LINIT raz ligne
LDD #$0000 numero du secteur a lire
STD <SD_LBA adresse physique (poids fort)
STD <SD_LBA+2 adresse physique (poids faible)
LDY >BUFFER adresse du buffer
JSR [RS512] lecture secteur 512 octets
LDX >BUFFER adresse du buffer
LDD #$55AA Signature secteur
CMPD $1FE,X Test signature
LBNE ERROR Signature incorrecte
* astuce pour differencier un MBR d'un Boot Sector
* le MBR a toujours $80 ou $00 en $1BE (pas certain)
LSL $1BE,X Boot indicator
BNE ABOOT1 Pas de MBR, donc boot record
* seule la premiere partition est exploree,
* son numero de secteur doit tenir dans deux octets
LDA $1C7,X LBA partition pds fort
LDB $1C6,X LBA partition pds faible
STD PSECT stockage secteur debut partition
*------------------------------------------------------
* Lecture du Boot Record
* Premier secteur au debut de la partition
* Registre D = numero secteur de debut de partition
*------------------------------------------------------
RBOOT
STD <SD_LBA+2 stockage pour CMD17 si carte SDHC
TST <SD_TYP test du type de carte
BNE RBOOT1 carte SDHC, sinon calcul pour SD
ASLB multiplie par 2 (poids faible)
ROLA multiplie par 2 (poids fort)
STD <SD_LBA+1 adresse = numero secteur * $200
CLRB raz registre A
STB <SD_LBA+3 raz dernier octet adresse
RBOOT1
LDY >BUFFER adresse du buffer
JSR [RS512] lecture du secteur de 512 octets
*------------------------------------------------------
* Analyse du Boot Sector
* $1FE-$1FF: $55AA (signature)
* $00B-$00C: nombre d'octets par secteur (512)
* $00D: nombre de secteurs par cluster
* $00E-$00F: nombre de secteurs reserves
* $010: nombre de FATs
* $011-$012: nombre entrees directory (FAT16 seulement)
* $016-$017: nombre secteurs FAT (FAT16 seulement)
* $024-$027: nombre secteurs FAT (FAT32 seulement)
* $02C-$02D: numero cluster directory (FAT32)
* Attention: le debut des donnees commence au cluster 2
* - En FAT16: apres la directory
* - En FAT32: apres les FATs
* Pour faciliter les calculs, on retranche 2 fois le
* nombre de secteurs par cluster au debut des donnees.
*
* Calcul du secteur physique du repertoire principal
* = numero du secteur de debut de partition
* + nombre de secteurs reserves
* + nombre de secteurs FAT * nombre de FAT
*
* Calcul du secteur physique du cluster zero
* = numero du secteur du debut du repertoire principal
* + nombre d'entrees repertoire / 16 (0 en FAT32)
* - nombre de secteurs par cluster * 2
*
*------------------------------------------------------
ABOOT
LDX >BUFFER adresse du buffer
LDD #$55AA Signature secteur
CMPD $1FE,X Test signature
LBNE ERROR Signature incorrecte
ABOOT1
CLRA
LDB $0D,X Nombre de secteurs par cluster
STD CSIZ2 Stockage nbre secteurs par cluster
LDA $0F,X Blocs reserves pds fort ex: $00
LDB $0E,X Blocs reserves pds faible ex: $04
STD RSECT stockage nbre secteurs reserves
* taille FAT (en FAT16) dans D
LDA $17,X Fat16 size pds fort ex: $00
LDB $16,X Fat16 size pds faible ex: $F2
STD $16,X stockage taille FAT16
BNE ABOOT2 FAT16 si different de zero
* taille FAT (en FAT32) dans D
* 2 octets poids fort ignores (simplification abusive ?)
LDA $25,X Fat32 size pds fort ex: $03
LDB $24,X Fat32 size pds faible ex: $AB
* taille totale fonction du nombre de FATs
ABOOT2
DEC $10,X Nombre de FAT ex: $02
BEQ ABOOT3 Une seule FAT
ASLB FAT size multiplie par 2 ex: $E4
ROLA FAT size multiplie par 2 ex: $01
* Le registre D contient le nombre de secteurs des FATs
* Les calculs suivants sont faux si le premier numero de
* secteur des donnees ne tient pas dans deux octets
ABOOT3
ADDD RSECT ajout nombre de secteurs reserves
ADDD PSECT ajout secteur de debut de partition
STD DSECT stockage secteur debut directory
LDA $12,X nbre entrees directory (poids fort)
LDB $11,X nbre entrees directory (poids faible)
LSRA division par 16
RORB pour obtenir
LSRA le nombre de secteurs
RORB de la directory
LSRA En FAT32 le nombre d'entrees
RORB de la directory est nul
LSRA Le debut des donnees (cluster 2)
RORB commence apres les FATs
ADDD DSECT ajout secteur debut directory
SUBD CSIZ2 retrancher le nbre secteurs/cluster
SUBD CSIZ2 retrancher le nbre secteurs/cluster
STD FSECT stockage numero secteur du cluster 0
LDD DSECT secteur de debut de directory
*------------------------------------------------------
* LECTURE DE LA DIRECTORY
* D contient le numero du secteur a lire
*------------------------------------------------------
RDSECT
STD <SD_LBA+2 stockage pour la commande 17
TST <SD_TYP type de carte 0=SD 1=SDHC
BNE RDSEC1 carte SDHC
ASLB LBA multiplie par 2
ROLA LBA multiplie par 2
STD <SD_LBA+1 LBA multiplie par $100
CLRB
STB <SD_LBA+3 octet de poids faible a zero
RDSEC1
LDY >BUFFER adresse du buffer
JSR [RS512] Lecture du secteur
LDX >BUFFER Adresse du buffer
*------------------------------------------------------
* LECTURE DES ENTREES DE LA DIRECTORY
* Le registre X pointe sur l'entree en cours
*------------------------------------------------------
RDIR1
LDB ,X lecture premier octet
LBEQ AFFIC $00 = fin de repertoire
CMPB #$E5 $E5 = entree annulee
BEQ RDIR9 entree suivante
LDB 11,X lecture attribut
ANDB #$0F selection demi-octet droit
CMPB #$0F attribut #$0F ?
BNE RDIR6 entree pour nom court
LBSR LNAME entree pour nom long
BRA RDIR9 entree suivante
RDIR6
LBSR GETLBA recherche du LBA
LDB [TFIN] premier caractere du nom
CMPB #$20 test espace
BNE RDIR7 non : il y a un nom long
LBSR SNAME oui : decodage nom court
RDIR7
LDY TFIN adresse ligne courante
LEAY 45,Y adresse ligne suivante
CMPY TMAX test taille de la table
BHI AFFIC table pleine
STY TFIN stockage adresse
LBSR LINIT raz ligne suivante
RDIR9
LEAX 32,X Adresse entree suivante
CMPX FINBUF Fin du buffer
BNE RDIR1 Traitement entree suivante
* lecture secteur suivant
LDD DSECT secteur debut directory
ADDD #$0001 secteur suivant
STD DSECT nouveau debut directory
BRA RDSECT lecture secteur directory
*------------------------------------------------------
* AFFICHAGE D'UNE LISTE DE 16 NOMS
*------------------------------------------------------
AFFIC
LBSR LOCAT6 positionnement ligne 6
LDB #$10 compteur de boucles
PSHS B empilage compteur
LDY TTOP adresse premier nom
AFFIC1
CMPY TFIN test fin de table
BLS AFFIC2 fin de table non depassee
LEAY -45,Y rester en fin de table
AFFIC2
LBSR DISP affichage d'une ligne
DEC ,S decrementation compteur
BNE AFFIC1 ligne suivante
PULS B depilage compteur
*------------------------------------------------------
* TEST DU CLAVIER
*------------------------------------------------------
CLAV
BSR RCHAR lecture du clavier
CMPB #$0D ENTREE
BEQ SETLBA changement image disquette
CMPB #$0A fleche bas
BEQ BAS ligne suivante
CMPB #$0B fleche haut
BEQ HAUT ligne precedente
BRA CLAV nouveau test
*------------------------------------------------------
* TRAITEMENT FLECHE VERS LE BAS
*------------------------------------------------------
BAS
LDY TSEL adresse ligne selectionnee
LEAY 45,Y adresse ligne suivante
CMPY TFIN test fin de table
BEQ CLAV ne rien faire en fin de table
STY TSEL stockage nouvelle adresse
* test de depassement bas ecran
LDY TTOP adresse haut ecran
LEAY 720,Y adresse haut ecran suivant
CMPY TSEL comparaison ligne selectionnee
BNE BAS1 pas de changement d'ecran
* changement d'ecran
STY TTOP haut de l'ecran suivant
BRA AFFIC nouvel affichage ecran complet
* pas de changement d'ecran
BAS1
LDY TSEL adresse ligne selectionnee
LEAY -45,Y adresse ligne precedente
LBSR LOCATY positionnement sur la ligne
LBSR DISP affichage ligne precedente
LBSR DISP affichage ligne selectionnee
BRA CLAV retour au test du clavier
*------------------------------------------------------
* TRAITEMENT FLECHE VERS LE HAUT
*------------------------------------------------------
HAUT
LDY TSEL adresse ligne selectionnee
CMPY TDEB test debut de table
BEQ CLAV ne rien faire en debut de table
LEAY -45,Y adresse ligne precedente
STY TSEL stockage nouvelle adresse
* test de depassement haut ecran
LDY TTOP adresse haut ecran
LEAY -45,Y adresse ligne precedente
CMPY TSEL comparaison ligne selectionnee
BNE HAUT1 pas de changement d'ecran
* changement d'ecran
LEAY -675,Y adresse page precedente
STY TTOP haut de l'ecran precedent
LBRA AFFIC nouvel affichage ecran complet
* pas de changement d'ecran
HAUT1
LDY TSEL adresse ligne selectionnee
LBSR LOCATY positionnement sur la ligne
LBSR DISP affichage ligne selectionnee
LBSR DISP affichage ligne suivante
BRA CLAV retour au test du clavier
*------------------------------------------------------
* LECTURE DU CLAVIER (RETOUR DANS LE REGISTRE B)
* Version pour TO remplacee par SWI #$8A pour MO
*------------------------------------------------------
RCHAR
JMP $E806 lecture du clavier
*------------------------------------------------------
* INITIALISATION LBA POUR CHANGEMENT IMAGE DISQUETTE
*------------------------------------------------------
SETLBA
LDY TSEL adresse ligne selectionnee
LDA CSIZE nombre de secteurs par cluster
* multiplication par le nombre de secteurs/cluster
SETLB1
LSRA divise par 2
BEQ SETLB2
LSL 44,Y decalage octet 4
ROL 43,Y decalage octet 3
ROL 42,Y decalage octet 2
ROL 41,Y decalage octet 1
BRA SETLB1 nouvelle boucle
* ajout du secteur du cluster zero
SETLB2
LDD FSECT numero secteur cluster zero
ADDB 44,Y ajout octet 4
ADCA 43,Y ajout octet 3 + retenue
STD 43,Y stockage octets 3 et 4
LDD 41,Y octets 1 et 2
ADCB #0 ajout retenue
ADCA #0 ajout retenue
STD 41,Y stockage octets 1 et 2
TST <SD_TYP test du type de carte
BNE SETLB4 carte SDHC, sinon calcul pour SD
* initialisation LBA du fichier pour carte SD
SETLB3
CLRB zero
STB <SD_LB0+3 octet 4 a zero
LDB 42,Y octet de poids fort
LSLB multiplie par 2
STB <SD_LB0 octet 1 (sans retenue)
LDD 43,Y octets 2 et 3
LSLB multiplication par 2
ROLA multiplication par 2
STD <SD_LB0+1 stockage octets 2 et 3
BCC RET_OK stockage LBA dans la carte
INC <SD_LB0 ajout retenue
BRA RET_OK stockage LBA dans la carte
* initialisation LBA du fichier pour carte SDHC
SETLB4
LDD 41,Y deux octets de poids fort
STD <SD_LB0 stockage
LDD 43,Y deux octets de poids faible
STD <SD_LB0+2 stockage
*------------------------------------------------------
* AFFICHAGE MESSAGES D'INFORMATION ET D'AIDE
*------------------------------------------------------
RET_OK
LDY #INFO adresse message de chargement
BSR WSTR affichage d'une ligne
LDY TSEL adresse nom de la disquette
LBSR DISP affichage d'une ligne
LDY #AIDE adresse aide tous modeles
BSR WSTR affichage aide tous modeles
TFR DP,A valeur registre DP
SUBA #$20 soustraire $20
BNE RET_TO TO si non nul
RET_MO
LDY #AIDEMO adresse aide MO
BRA RETOUR
RET_TO
LDY #AIDETO adresse aide TO
*------------------------------------------------------
* AFFICHAGE AIDE, SELECTION VIDEO COULEUR,
* RESTAURATION POINTEUR DE PILE ET RETOUR
*------------------------------------------------------
RETOUR
BSR WSTR affichage aide specifique
BSR VIDEOC selection video couleur MO
ANDCC #$AF active les interruptions
LDS SAVES restauration du registre S
RTS
*------------------------------------------------------
* RETOUR EN ERREUR
*------------------------------------------------------
ERROR
LDY #ERREUR
BSR WSTR
BRA RETOUR
*------------------------------------------------------
* SELECTION PAGE VIDEO COULEUR POUR MO UNIQUEMENT
*------------------------------------------------------
VIDEOC
LDB >$FFF2 poids fort du vecteur SWI3
BPL VIDEO9 positif --> TO
LDA $A7C0 chargement PA du PIA systeme
ANDA #$FE raz b0 (page video couleur)
STA $A7C0 selection video couleur
VIDEO9
RTS
*------------------------------------------------------
* LECTURE ET STOCKAGE DU CLUSTER DU FICHIER
*------------------------------------------------------
GETLBA
LDY TFIN Y pointe sur la zone du nom
LDA 21,X cluster octet 1
STA 41,Y LBA octet 1
LDA 20,X cluster octet 2
STA 42,Y LBA octet 2
LDA 27,X cluster octet 3
STA 43,Y LBA octet 3
LDA 26,X cluster octet 4
STA 44,Y LBA octet 4
RTS
*------------------------------------------------------
* AFFICHAGE CHAINE TERMINEE PAR ZERO (Adresse dans Y)
*------------------------------------------------------
WSTR
LDB ,Y+ caractere a ecrire
BEQ WSTR9 fin de la chainee
BSR WCHAR envoi caractere
BRA WSTR caractere suivant
WSTR9
RTS
*------------------------------------------------------
* AFFICHAGE CARACTERE (CARACTERE DANS REGISTRE B)
* Version TO remplacee par SWI #$82 pour MO
*------------------------------------------------------
WCHAR
JMP $E803 envoi caractere
*------------------------------------------------------
* AFFICHAGE D'UNE LIGNE POINTEE PAR Y
* AU RETOUR Y POINTE SUR LA LIGNE SUIVANTE
*------------------------------------------------------
DISP
CMPY TSEL test ligne selectionnee
BNE DISP1 ligne normale
BSR INVERS inversion video
DISP1
LDA #$29 nombre de caracteres 41
DISP2
LDB ,Y+ caractere a ecrire
BSR WCHAR envoi caractere
DECA decrementation compteur
BNE DISP2 caractere suivant
LEAY -41,Y
CMPY TSEL test ligne selectionnee
BNE DISP9 ligne normale
BSR INVERS retablir video normale
DISP9
LEAY 45,Y adresse ligne suivante
RTS
*------------------------------------------------------
* INVERSION VIDEO
*------------------------------------------------------
INVERS
LDB #$1B sequence d'echappement
BSR WCHAR envoi caractere
INVER1
LDB #$5C inverse video pour TO
* remplace par #$7B pour MO
BSR WCHAR envoi caractere
RTS
*------------------------------------------------------
* POSITIONNEMENT SUR LA LIGNE 6
*------------------------------------------------------
LOCAT6
LDB #$1F code de positionnement
BSR WCHAR envoi caractere
LDB #$46 ligne 6
BSR WCHAR envoi caractere
LDB #$41 colonne 1
BSR WCHAR envoi caractere
RTS
*------------------------------------------------------
* POSITIONNEMENT SUR LA LIGNE POINTEE PAR Y
*------------------------------------------------------
LOCATY
PSHS Y sauvegarde Y
LDB #$1F code de positionnement
BSR WCHAR envoi caractere
LDB #$46 code pour pointer ligne 6
LOC1
CMPY TTOP comparaison a la premiere ligne
BEQ LOC2 positionnement ligne B
INCB numero ligne suivante
LEAY -45,Y adresse ligne precedente
BRA LOC1 nouvelle boucle
LOC2
BSR WCHAR envoi caractere
LDB #$41 colonne 1
BSR WCHAR envoi caractere
PULS Y,PC retour
*------------------------------------------------------
* INITIALISATION NOUVELLE LIGNE DE 45 CARACTERES
* NOM(39 OCTETS) + CR + LF + ADRESSE(4 OCTETS)
*------------------------------------------------------
LINIT
LDY TFIN
LDD #$202D espace et 45 boucles
LINIT1
STA ,Y+ octet initialise a espace
DECB decrementation compteur
BNE LINIT1 octet suivant
LDD #$0D0A CR+LF
STD -6,Y ajout CR+LF
RTS
*------------------------------------------------------
* EXTRACTION DES CARACTERES DU NOM COURT
*------------------------------------------------------
SNAME
LDY TFIN Y pointe sur la zone du nom
CLRB compteur de caracteres
SNAME1
LDA B,X lecture caractere
CMPA #$20 test espace
BEQ SNAME3 ignorer les espaces
CMPA #$41 caractere A
BLO SNAME2 copier si < A
CMPA #$5A caractere Z
BHI SNAME2 copier si > Z
ORA #$20 passer en minuscules
SNAME2
STA ,Y+ stockage caractere
SNAME3
INCB caractere suivant
CMPB #$08 huitieme caractere
BNE SNAME4 sinon rien de plus
LDA #$2E ajouter un point
STA ,Y+ stockage point
SNAME4
CMPB #$0B onzieme caractere
BNE SNAME1 caractere suivant
RTS
*------------------------------------------------------
* EXTRACTION DES CARACTERES DU NOM LONG
*------------------------------------------------------
LNAME
LDY TFIN Y pointe sur la zone du nom
LDA #$0D nbre de caracteres par entree
LDB ,X sequence number
ANDB #$BF slot number
CMPB #$03 comparaison avec 3
BHI LNAME9 Si superieur ne pas traiter
MUL multiplier par 13
SUBD #$0D moins 13 --> position 1er caractere
LEAY B,Y Y pointe sur 1er caractere
LDA 1,X 1er caractere
STA ,Y+ stockage
LDA 3,X 2eme caractere
STA ,Y+ stockage
LDA 5,X 3eme caractere
STA ,Y+ stockage
LDA 7,X 4eme caractere
STA ,Y+ stockage
LDA 9,X 5eme caractere
STA ,Y+ stockage
LDA 14,X 6eme caractere
STA ,Y+ stockage
LDA 16,X 7eme caractere
STA ,Y+ stockage
LDA 18,X 8eme caractere
STA ,Y+ stockage
LDA 20,X 9eme caractere
STA ,Y+ stockage
LDA 22,X 10eme caractere
STA ,Y+ stockage
LDA 24,X 11eme caractere
STA ,Y+ stockage
LDA 28,X 12eme caractere
STA ,Y+ stockage
LDA 30,X 13eme caractere
STA ,Y+ stockage
LDB #$0D compteur pour 13 boucles
LNAME2
LDA ,-Y caractere du nom
BEQ LNAME3 test $00
INCA transforme $FF en $00
BNE LNAME4 test $FF
LNAME3
LDA #$20 blanc remplace $00 et $FF
STA ,Y stockage dans le nom
LNAME4
DECB decrementation compteur
BNE LNAME2 boucle suivante
LNAME9
RTS
*------------------------------------------------------
* Initialisation ecran
*------------------------------------------------------
ECRAN
FCB $0C effacement ecran
FCB $1B,$20,$40 couleur noire
FCB $1B,$20,$57 fond blanc
FCB $1B,$67 bordure blanche
FCB $1F,$57,$41 locate 1,23
FCB $1B,$46 ecriture cyan
FCC "Fleches bas et haut, ENTREE pour valider"
FCB $1F,$45,$41 locate 1,5
FCB $1B,$40,$00 ecriture noire
*------------------------------------------------------
* Message d'information
*------------------------------------------------------
INFO
FCB $0C effacement ecran
FCB $1B,$20,$44 couleur bleu
FCB $1B,$20,$56 fond cyan
FCB $1B,$66 bordure cyan
FCC "Disquette chargee :"
FCB $0D,$0A,$00
*------------------------------------------------------
* Message d'aide
*------------------------------------------------------
AIDE
FCB $0D,$0A
FCC /Commandes utiles:/
FCB $0D,$0A
FCC /DIR 'List directory/
FCB $0D,$0A
FCC /RUN"AUTO.BAT" 'Start program/
FCB $0D,$0A,$00
AIDEMO
FCC /EXEC&HA007 'Boot on disk/
FCB $0D,$0A
FCC /CLEAR,&H4FFF:EXEC&HA025 'Change disk/
FCB $0D,$0A,$0D,$0A,$00
AIDETO
FCC /EXEC&HE007 'Boot on disk/
FCB $0D,$0A
FCC /CLEAR,&H8FFF:EXEC&HE025 'Change disk/
FCB $0D,$0A,$0D,$0A,$00
*------------------------------------------------------
* Message d'erreur
*------------------------------------------------------
ERREUR
FCB $0C
FCC " Format de la carte SD non reconnu"
FCB $0D,$0A,$0D,$0A,$00
*------------------------------------------------------
* Logo ARDRIVE avec compactage
* Si un octet est inferieur a $20, c'est le nombre de
* repetitions de l'octet suivant. Les octets utiles
* doivent être augmentes de $43.
* L'affichage se fait par colonne de gauche a droite
* et de haut en bas.
*------------------------------------------------------
SDLOGO
FDB $10BD,$02BE,$02BF,$02C1,$02C5,$02CD,$02DD,$02FD
FDB $3DBC,$02BE,$02BF,$02C1,$02C5,$02CD,$02DD,$02FD
FDB $023D,$0ABD,$CCC5,$02CD,$DD9D,$BC09,$BD02,$C502
FDB $D102,$DF02,$FE3D,$BC06,$BDBC,$05BD,$7DFD,$02DD
FDB $02CD,$02C5,$02C1,$02BF,$02BE,$04BD,$023D,$06BD
FDB $B5C5,$02C1,$BFC0,$0EBD,$023D,$02FD,$02DD,$02CD
FDB $02C5,$02C1,$02BF,$02BE,$BDBC,$C41D,$C141,$44BC
FDB $07BD,$C006,$BFC0,$07BD,$C007,$BFBB,$BC07,$BDBC
FDB $06BD,$BC07,$BDBC,$08BD,$BC07,$BDBC,$06BD,$BC07
FDB $BD7D,$DDCD,$C5C1,$BFBE,$02BD,$BC07,$BD7D,$DD04
FDB $CDDD,$7D07,$BDCC,$C1BF,$BE03,$BD3D,$3CBD,$7DDD
FDB $02CD,$0EC5,$02CD,$DD7D,$04BD,$3DFD,$DDCD,$B53C
FDB $1EFD,$3CBC,$07BD,$FC0E,$DDFC,$07BD,$02BC,$07BD
FDB $BC0E,$BDBC,$07BD,$02BC,$07BD,$BBBE,$0CBD,$BEBB
FDB $07BD,$BCB5,$C3BE,$07BD,$0C3D,$07BD,$BEC3,$B5C0
FDB $02BF,$023F,$16FF,$023F,$02BF,$C0BC,$07BD,$10BE
FDB $07BD,$02BC,$07BD,$BC0E,$BDBC,$07BD,$02BC,$07BD
FDB $BC0E,$BDBC,$07BD,$02BC,$07BD,$ADC5,$0CC1,$C5AD
FDB $07BD,$BC7D,$EDC5,$02C1,$16BF,$02C1,$C5ED,$7DDC
FDB $1ECD,$DCBC,$07BD,$CC06,$C5CC,$07BD,$CC07,$C5B5
FDB $BC07,$BDBC,$06BD,$BC07,$BDBC,$08BD,$BC07,$BDBC
FDB $06BD,$BC08,$BD3D,$FDDD,$CDC5,$C1BF,$BEB9,$C007
FDB $BD3D,$04FD,$3D07,$BDC0,$F9CD,$C5C1,$BFBE,$02BD
FDB $BC02,$BE3E,$02FE,$0EDE,$02FE,$3E07,$BE3E,$FE9E
FDB $BC1E,$BDBC,$4441,$023F,$023E,$1A3D,$BCBE,$04BD
FDB $023D,$02FD,$02DD,$02CD,$02C5,$02C1,$02BF,$02BE
FDB $0CBD,$023D,$02FD,$02DD,$02CD,$02C5,$02C1,$02BF
FDB $02BE,$04BD,$023D,$02FD,$02DD,$02CD,$C5CC,$08BD
FDB $02BE,$02BF,$02C1,$02C5,$02CD,$025D,$02FD,$06BD
FDB $02BE,$BFBB,$DCCD,$02DD,$02FD,$023D,$04BD,$02BE
FDB $02BF,$02C1,$02C5,$02CD,$02DD,$02FD,$023D,$04BD
FDB $B9C1,$02C5,$02CD,$02DD,$02FD,$023D,$14BD,$FC1E
FDB $DDFC,$BC07,$BDDC,$03CD,$DC06,$BDDC,$03CD,$DC07
FDB $BD02,$BC07,$BDBC,$03BD,$BC06,$BDBC,$03BD,$BC07
FDB $BD02,$BC07,$BDBC,$03BD,$B506,$C5B5,$03BD,$BC07
FDB $BD02,$BC07,$BEBC,$0EBD,$BC07,$BEBC,$0000
*------------------------------------------------------
* Zones de TRAVAIL
*------------------------------------------------------
RS512
FDB $E02B fonction de lecture secteur (TO)
CSIZ2
FCB $00 nombre de secteurs par cluster (sur 2 octets)
CSIZE
FCB $00 nombre de secteurs par cluster (sur 1 octet)
RSECT
FDB $0000 nombre de secteurs reserves
PSECT
FDB $0000 numero secteur debut partition
DSECT
FDB $0000 numero secteur debut directory
FSECT
FDB $0000 numero secteur de data cluster 0
BUFFER
FDB $9D00 adresse buffer de lecture carte SD
FINBUF
FDB $9F00 adresse de fin du buffer de lecture
TDEB
FDB $A000 adresse debut table des noms (TO)
TFIN
FDB $A000 adresse fin table des noms
TTOP
FDB $A000 adresse nom en haut d'ecran (TO)
TSEL
FDB $A000 adresse nom selectionne (TO)
TMAX
FDB $E000 limite haute de la table des noms (TO)
SAVES
FDB $0000 sauvegarde du registre S
END
Daniel
L'obstacle augmente mon ardeur.
L'obstacle augmente mon ardeur.
- fneck
- Site Admin
- Messages : 17426
- Inscription : 01 avr. 2007 12:03
- Localisation : Drôme Provençale (26)
- Contact :
Re: [THOMSON] ARDDRIVE
Je vais être obligé d'intervenir une nouvelle fois dans les débats, ici et dans l'autre sujet, mais laisser moi un peu de temps, là je dois partir....
Fabien https://www.system-cfg.com
Les bonnes pratiques de l'utilisateur du forum viewtopic.php?f=14&t=3
Les bonnes pratiques de l'utilisateur du forum viewtopic.php?f=14&t=3
-
- Messages : 7924
- Inscription : 18 sept. 2010 12:08
- Localisation : Brest et parfois les Flandres
Re: [THOMSON] ARDDRIVE
Oui très certainement, car le bruit court que tout cela est très facile à mettre en oeuvre, à la portée d'un débutant (on précise pas en quoi). Tant mieux, plus il y a d'options plus on a de possibilités de faire des trucs sympa sur thomson, et ca c'est bien (les trucs sympa en général, et sur thomson en particulier).
Samuel.
A500 Vampire V2+ ^8^, A1200 (030@50mhz/fpu/64mb/cf 8go),
A500 GVP530(MMU/FPU) h.s., R-Pi, TO9, TO8D, TO8.Démos
A500 Vampire V2+ ^8^, A1200 (030@50mhz/fpu/64mb/cf 8go),
A500 GVP530(MMU/FPU) h.s., R-Pi, TO9, TO8D, TO8.Démos
Re: [THOMSON] ARDDRIVE
J'ai retrouvé la version CompactFlash de Farewell Angelina, à essayer avec l'exécutable windows ci-dessous :
http://dl.free.fr/fsKQEuVXa (hébergement provisoire 30 jours).
Comparée à la version SDDRIVE de __sam__ (postée un peu plus haut dans ce fil de discussion) je la trouve plutôt moins bonne, et surtout plus saccadée, comme quoi le matériel ne fait pas tout. Avec un débit six fois plus faible un bon programmeur est capable de faire mieux.
Daniel
L'obstacle augmente mon ardeur.
L'obstacle augmente mon ardeur.
-
- Messages : 7924
- Inscription : 18 sept. 2010 12:08
- Localisation : Brest et parfois les Flandres
Re: [THOMSON] ARDDRIVE
En fait c'est comme le lecteur de diskette: tout réside dans le bon entrelacement!
En fait dans ma vidéo je ne traite pas la mémoire de façon linéaire, mais j'entrelace les lignes non pas paires/impaires, mais avec un truc plus évolué et adapté au motif du tramage. L'idée de l'entrelacement est que si le débit tombe, alors au lieu de n'afficher que le 1/3 supérieur de l'image avec une organisation linéaire de la mémoire, l'entrelacement va juste mettre à jour à l'écran une ligne sur 3. On verra donc 66% de l'ancienne image et 33% de la nouvelle, plus loin il mettra à jour un autre tiers d'écran et on passera à 33% de l'ancienne image à 66% de la nouvelle. En gros cela réalise un fondu sur image progressif ce qui fluidifie les baisses de débit et est plus plaisant à l'oeil que les rafraîchissements partiels d'un bout de l'écran.
(Bien entendu ce que je dis là à propos des 33% n'est qu'un exemple, il faut trouver une technique qui s'adapte aux chute de débit pouvant descendre beaucoup plus bas en fonction du FPS désiré, mais bon c'est le principe qui compte.)
En fait dans ma vidéo je ne traite pas la mémoire de façon linéaire, mais j'entrelace les lignes non pas paires/impaires, mais avec un truc plus évolué et adapté au motif du tramage. L'idée de l'entrelacement est que si le débit tombe, alors au lieu de n'afficher que le 1/3 supérieur de l'image avec une organisation linéaire de la mémoire, l'entrelacement va juste mettre à jour à l'écran une ligne sur 3. On verra donc 66% de l'ancienne image et 33% de la nouvelle, plus loin il mettra à jour un autre tiers d'écran et on passera à 33% de l'ancienne image à 66% de la nouvelle. En gros cela réalise un fondu sur image progressif ce qui fluidifie les baisses de débit et est plus plaisant à l'oeil que les rafraîchissements partiels d'un bout de l'écran.
(Bien entendu ce que je dis là à propos des 33% n'est qu'un exemple, il faut trouver une technique qui s'adapte aux chute de débit pouvant descendre beaucoup plus bas en fonction du FPS désiré, mais bon c'est le principe qui compte.)
Samuel.
A500 Vampire V2+ ^8^, A1200 (030@50mhz/fpu/64mb/cf 8go),
A500 GVP530(MMU/FPU) h.s., R-Pi, TO9, TO8D, TO8.Démos
A500 Vampire V2+ ^8^, A1200 (030@50mhz/fpu/64mb/cf 8go),
A500 GVP530(MMU/FPU) h.s., R-Pi, TO9, TO8D, TO8.Démos
Re: [THOMSON] ARDDRIVE
donc si je comprends bien, si au lieu de prendre un arduino, il avait été choisi un hard avec RAM plus importante, il n'y aurait aucun problème?
car pourquoi s'entêter à lire la carte SD bit à bit avec synchro... s'il suffit de charger le contenu du fichier .sd directement en RAM et de l'envoyer vers le Thomson sans avoir les mêmes problèmes de synchro?
Parce que la description du projet par sam montre bien qu'il a fallu passer par des tas de projets matériels différents avant d'arriver à SDDRIVE.
quant à l'explication de Daniel comme quoi il ne maîtrise pas le Raspberry PI ça me paraît quand même très bizarre. J'ai lu le code source en C de DCTO8 et Daniel maitrise très bien le C. Le Raspberry PI se programmant aussi en C je ne vois pas trop le problème pour faire une interface soft depuis un Raspberry PI...
Pour la synchro depuis un Raspberry PI, le port GPIO dispose de nombreuses broches. Pourquoi n'est il pas possible d'en utiliser une en entrée et une en sortie pour un signal RTS/CTS. Le Thomson veut des données il envoi un signal sur une broche simplement. Les données étant en RAM elles sont toujours disponibles sans latence et les données peuvent être envoyées en parallèle par le Raspberry PI.
Les projets comme ça existent depuis la nuit des temps puisqu'on faisait déjà du transfert de fichier bidirectionnel avec un port parallèle unidirectionnel en utilisant la broche destinée à indiquer le manque de papier.
car pourquoi s'entêter à lire la carte SD bit à bit avec synchro... s'il suffit de charger le contenu du fichier .sd directement en RAM et de l'envoyer vers le Thomson sans avoir les mêmes problèmes de synchro?
Parce que la description du projet par sam montre bien qu'il a fallu passer par des tas de projets matériels différents avant d'arriver à SDDRIVE.
quant à l'explication de Daniel comme quoi il ne maîtrise pas le Raspberry PI ça me paraît quand même très bizarre. J'ai lu le code source en C de DCTO8 et Daniel maitrise très bien le C. Le Raspberry PI se programmant aussi en C je ne vois pas trop le problème pour faire une interface soft depuis un Raspberry PI...
Pour la synchro depuis un Raspberry PI, le port GPIO dispose de nombreuses broches. Pourquoi n'est il pas possible d'en utiliser une en entrée et une en sortie pour un signal RTS/CTS. Le Thomson veut des données il envoi un signal sur une broche simplement. Les données étant en RAM elles sont toujours disponibles sans latence et les données peuvent être envoyées en parallèle par le Raspberry PI.
Les projets comme ça existent depuis la nuit des temps puisqu'on faisait déjà du transfert de fichier bidirectionnel avec un port parallèle unidirectionnel en utilisant la broche destinée à indiquer le manque de papier.
Dernière modification par totor le 01 nov. 2019 17:48, modifié 1 fois.
Re: [THOMSON] ARDDRIVE
La RAM est effectivement une bonne solution pour les démos. L'inconvénient, c'est le temps de chargement, mais pourquoi pas. Pour une utilisation confortable il faudrait aux environs de 64 Mo. Sur le papier ça ne paraît pas impossible. Peux-tu nous donner des conseils ?
[Edit] Je me suis mal exprimé. Je voulais parler de RAM sur l'ordinateur Thomson, pas sur le RPI.
Pour lire un octet sur le RPI, il faudrait envoyer un signal (minimum 4 cycles), lire l'octet (minimum 4 cyles) en faire quelque chose (minimum 4 cycles), basculer le signal (minimum 4 cycles). Donc environ 83 000 octets pas seconde. Ce n'est pas assez.
[Edit] Je me suis mal exprimé. Je voulais parler de RAM sur l'ordinateur Thomson, pas sur le RPI.
Pour lire un octet sur le RPI, il faudrait envoyer un signal (minimum 4 cycles), lire l'octet (minimum 4 cyles) en faire quelque chose (minimum 4 cycles), basculer le signal (minimum 4 cycles). Donc environ 83 000 octets pas seconde. Ce n'est pas assez.
Dernière modification par Daniel le 01 nov. 2019 17:45, modifié 1 fois.
Daniel
L'obstacle augmente mon ardeur.
L'obstacle augmente mon ardeur.
Re: [THOMSON] ARDDRIVE
comme je le disais plus haut après avoir modifié plusieurs fois mon message, j'ai déjà réalisé des projets softs de transfert de données en utilisant les signaux RTS/DTS.
pourquoi n'est il pas possible que si le contenu SD est en RAM, le Thomson envoie un signal sur une broche indiquant qu'il veut des données. Il reçoit 8 bits les traite et envoie à nouveau le signal demandant les données.
Comme on le faisait avec les câbles parallèles unidirectionnels en utilisant la broche "manque de papier".
Ainsi il n'y a pas besoin de synchro précise.
quel est le problème avec cette approche?
exemple
LDA $E7D0 pour lire un octet ...
et par comparaison les instructions que tu utilises pour lire le même octet depuis l'arduino (directement sur la carte SD).
pourquoi n'est il pas possible que si le contenu SD est en RAM, le Thomson envoie un signal sur une broche indiquant qu'il veut des données. Il reçoit 8 bits les traite et envoie à nouveau le signal demandant les données.
Comme on le faisait avec les câbles parallèles unidirectionnels en utilisant la broche "manque de papier".
Ainsi il n'y a pas besoin de synchro précise.
quel est le problème avec cette approche?
Te serait il possible de mettre ici les instructions assembleurs que tu utiliserais pour ça et qui prendraient les 4 cycles?faudrait envoyer un signal (minimum 4 cyles), lire l'octet (minimum 4 cyles) en faire quelque chose (minimum 4 cycles), basculer le signal (minimum 4 cycles)
exemple
LDA $E7D0 pour lire un octet ...
et par comparaison les instructions que tu utilises pour lire le même octet depuis l'arduino (directement sur la carte SD).
Re: [THOMSON] ARDDRIVE
LDA $E7D0, c'est 5 cycles
STA $A7CD (par exemple pour jouer de la musique), c'est 5 cycles
STB $E7D1, c'est 5 cycles
CLR $E7D1, c'est 7 cycles
Bon j'ai volontairement exagéré, on peut faire moins avec l'adressage direct (4+4+4+6), mais c'est au plus 55000 octets par seconde, comparés aux 120000 octets par seconde de SDANIM7 avec un Arduino.
Dans ARDDRIVE (avec l'Arduino), la lecture d'un octet c'est LDA <$BF (4 cycles)
Le signal demandant le transfert est envoyé par le hard (donc 0 cycle), comme dans SDDRIVE.
Par contre, 64 Mo de RAM sur le Thomson, c'est une excellente idée à creuser.
STA $A7CD (par exemple pour jouer de la musique), c'est 5 cycles
STB $E7D1, c'est 5 cycles
CLR $E7D1, c'est 7 cycles
Bon j'ai volontairement exagéré, on peut faire moins avec l'adressage direct (4+4+4+6), mais c'est au plus 55000 octets par seconde, comparés aux 120000 octets par seconde de SDANIM7 avec un Arduino.
Dans ARDDRIVE (avec l'Arduino), la lecture d'un octet c'est LDA <$BF (4 cycles)
Le signal demandant le transfert est envoyé par le hard (donc 0 cycle), comme dans SDDRIVE.
Par contre, 64 Mo de RAM sur le Thomson, c'est une excellente idée à creuser.
Dernière modification par Daniel le 01 nov. 2019 18:05, modifié 1 fois.
Daniel
L'obstacle augmente mon ardeur.
L'obstacle augmente mon ardeur.
Re: [THOMSON] ARDDRIVE
Ok je comprends les instructions que tu viens de mettre mais ma question est plutôt :
Donc ma question est : quelles instructions 6809E utilises tu pour ces 250 000 octets/seconde que je puisse comparer avec le mode Raspberry PI et pourquoi tu arrives à 250 000 octets/seconde avec un Arduino et qu'il ne serait pas possible de le faire avec un RPI ?
Donc dès le départ tu es parti sur des instructions 6809E qui te permettaient de lire 250 000 octets/seconde grâce à un Arduino.ARDDRIVE est un nouveau projet de contrôleur de disquette utilisant des fichiers images sur carte SD. Par rapport à SDDRIVE, le débit passe de 20 000 octets/seconde à 250 000 octets/seconde, grâce à un Arduino accédant à la carte SD en mode SPI et échangeant les données avec l'ordinateur Thomson en parallèle sur 8 bits.
Donc ma question est : quelles instructions 6809E utilises tu pour ces 250 000 octets/seconde que je puisse comparer avec le mode Raspberry PI et pourquoi tu arrives à 250 000 octets/seconde avec un Arduino et qu'il ne serait pas possible de le faire avec un RPI ?