[THOMSON] ARDDRIVE

Cette catégorie traite de développements récents destinés à nos vieilles machines, applications, jeux ou démos... Amis programmeurs, c'est ici que vous pourrez enfin devenir célèbres!

Modérateurs : Papy.G, fneck, Carl

Répondre
__sam__
Messages : 7924
Inscription : 18 sept. 2010 12:08
Localisation : Brest et parfois les Flandres

Re: [THOMSON] ARDDRIVE

Message par __sam__ »

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 :shock: .

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 :P .)

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. :roll: 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
Daniel
Messages : 17319
Inscription : 01 mai 2007 18:30
Localisation : Vaucluse
Contact :

Re: [THOMSON] ARDDRIVE

Message par Daniel »

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.
Daniel
L'obstacle augmente mon ardeur.
Daniel
Messages : 17319
Inscription : 01 mai 2007 18:30
Localisation : Vaucluse
Contact :

Re: [THOMSON] ARDDRIVE

Message par Daniel »

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 :wink: :wink: :wink:

sd-ide.jpg
sd-ide.jpg (41.03 Kio) Consulté 3940 fois
Daniel
L'obstacle augmente mon ardeur.
nicolho
Messages : 409
Inscription : 10 nov. 2016 16:53

Re: [THOMSON] ARDDRIVE

Message par nicolho »

[supp modo: propos déplacés]
Daniel
Messages : 17319
Inscription : 01 mai 2007 18:30
Localisation : Vaucluse
Contact :

Re: [THOMSON] ARDDRIVE

Message par Daniel »

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 :

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.
Daniel
Messages : 17319
Inscription : 01 mai 2007 18:30
Localisation : Vaucluse
Contact :

Re: [THOMSON] ARDDRIVE

Message par Daniel »

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.
Avatar de l’utilisateur
fneck
Site Admin
Messages : 17426
Inscription : 01 avr. 2007 12:03
Localisation : Drôme Provençale (26)
Contact :

Re: [THOMSON] ARDDRIVE

Message par fneck »

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
__sam__
Messages : 7924
Inscription : 18 sept. 2010 12:08
Localisation : Brest et parfois les Flandres

Re: [THOMSON] ARDDRIVE

Message par __sam__ »

Daniel a écrit : 01 nov. 2019 09:33 D'ici là un RPIDRIVE sera probablement disponible, les utilisateurs pourront choisir :wink: :wink: :wink:
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
Daniel
Messages : 17319
Inscription : 01 mai 2007 18:30
Localisation : Vaucluse
Contact :

Re: [THOMSON] ARDDRIVE

Message par Daniel »

Daniel a écrit : 29 oct. 2019 19:04 J'ai fait quelques démonstrations de vidéo à des membres du forum (C'était Joan Baez, Farewell Angelina, pour ceux qui s'en souviennent)
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.

farewell_angelina.png
farewell_angelina.png (3.61 Kio) Consulté 3893 fois
Daniel
L'obstacle augmente mon ardeur.
__sam__
Messages : 7924
Inscription : 18 sept. 2010 12:08
Localisation : Brest et parfois les Flandres

Re: [THOMSON] ARDDRIVE

Message par __sam__ »

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.)
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
totor
Messages : 204
Inscription : 09 oct. 2019 22:41

Re: [THOMSON] ARDDRIVE

Message par totor »

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.
Dernière modification par totor le 01 nov. 2019 17:48, modifié 1 fois.
Daniel
Messages : 17319
Inscription : 01 mai 2007 18:30
Localisation : Vaucluse
Contact :

Re: [THOMSON] ARDDRIVE

Message par Daniel »

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.
Dernière modification par Daniel le 01 nov. 2019 17:45, modifié 1 fois.
Daniel
L'obstacle augmente mon ardeur.
totor
Messages : 204
Inscription : 09 oct. 2019 22:41

Re: [THOMSON] ARDDRIVE

Message par totor »

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?
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)
Te serait il possible de mettre ici les instructions assembleurs que tu utiliserais pour ça et qui prendraient les 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).
Daniel
Messages : 17319
Inscription : 01 mai 2007 18:30
Localisation : Vaucluse
Contact :

Re: [THOMSON] ARDDRIVE

Message par Daniel »

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.
Dernière modification par Daniel le 01 nov. 2019 18:05, modifié 1 fois.
Daniel
L'obstacle augmente mon ardeur.
totor
Messages : 204
Inscription : 09 oct. 2019 22:41

Re: [THOMSON] ARDDRIVE

Message par totor »

Ok je comprends les instructions que tu viens de mettre mais ma question est plutôt :
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 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.

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 ?
Répondre